网站建设要求 优帮云,wordpress 好用的编辑器,天津微信小程序开发公司,企业排行榜力扣的算法题#xff1a;1154 给你一个字符串 date #xff0c;按 YYYY-MM-DD 格式表示一个 现行公元纪年法 日期。返回该日期是当年的第几天。 示例 1#xff1a; 输入#xff1a;date “2019-01-09” 输出#xff1a;9 解释#xff1a;给定日期是2019年的第九天。 示例…力扣的算法题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 0let year (dateArray[0] as NSString).intValuelet month (dateArray[1] as NSString).intValuelet day (dateArray[2] as NSString).intValuelet 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 0var right s.count-1//! 字符串小写并转化为数组let array Array(s.lowercased())while left right {if !array[left].isLetter !array[left].isNumber {left1continue}if !array[right].isLetter !array[right].isNumber {right-1continue}if array[left] array[right] {left1right-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-1while left right {let leftI s[left]let rightI s[right]let temp s[right]s[right] s[left]s[left] templeft left 1right 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 tvar 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 1charDic.updateValue(count, forKey: char)} else {charDic[char] 1}}var maxCount 0var hasJiShuCount falsefor (_, value) in charDic {if value % 2 0 {maxCount maxCount value} else {maxCount maxCount value - 1hasJiShuCount 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 - 1var lastNoSameIndex 0var hasFirstNoSameIndex truefor i in 0...count {if goalArray[i] ! sArray[i] {if hasFirstNoSameIndex {lastNoSameIndex ihasFirstNoSameIndex 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 trueprefixString 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 0while count 4 {offset offset 3newNumber.insert(-, at: newNumber.index(newNumber.startIndex, offsetBy: offset))// 因为插入了一个 “- ”符号所以要加1offset offset 1count 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 0var countL 0var lastChar for char in s {if char A {lastChar countL 0countA 1if countA 1 {return false}} else if char L {countL 1if 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-650)/4 51/4 12.75 示例 2 输入nums [5], k 1 输出5.00000 class Solution {func findMaxAverage(_ nums: [Int], _ k: Int) - Double {var sum 0var maxSum 0for 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[0].countlet count grid.countvar newGird [[Int]]()newGird.append([Int](repeating: 0, count: length 2))for i in 0..count {var temp grid[i]temp.insert(0, at: 0)temp.insert(0, at: length 1)newGird.append(temp)}newGird.append([Int](repeating: 0, count: length 2))var landLength 0for i in 1..newGird.count {let lineBefore newGird[i-1]let lineCurrent newGird[i]for j in 1..lineCurrent.count {if lineBefore[j] ! lineCurrent[j] {landLength 1}if lineCurrent[j] ! lineCurrent[j-1] {landLength 1}}}return landLength}
}234. 回文链表 给你一个单链表的头节点 head 请你判断该链表是否为回文链表。如果是返回 true 否则返回 false 。 示例 1 输入head [1,2,2,1] 输出true 示例 2 输入head [1,2] 输出false class Solution {func isPalindrome(_ head: ListNode?) - Bool {if head nil {return false}var nodeArray:[Int] [Int]()var temp headwhile temp ! nil {let next temp?.valnodeArray.append(next ?? 0)temp temp?.next}var leftI 0var rightI nodeArray.count - 1while leftI rightI {if nodeArray[leftI] nodeArray[rightI] {leftI 1rightI - 1} else {return false}}return true}
}141. 环形链表 给你一个链表的头节点 head 判断链表中是否有环。 如果链表中有某个节点可以通过连续跟踪 next 指针再次到达则链表中存在环。 为了表示给定链表中的环评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置索引从 0 开始。注意pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。 如果链表中存在环 则返回 true 。 否则返回 false 。 输入head [3,2,0,-4], pos 1 输出true 解释链表中有一个环其尾部连接到第二个节点。 /*** Definition for singly-linked list.* public class ListNode {* public var val: Int* public var next: ListNode?* public init(_ val: Int) {* self.val val* self.next nil* }* }*/class Solution {func hasCycle(_ head: ListNode?) - Bool {var oneNode head?.next;var twoNode head?.next?.next;while oneNode ! nil twoNode ! nil {if oneNode twoNode {return true} else {oneNode oneNode?.nexttwoNode twoNode?.next?.next}}return false}
}468. 验证IP地址 给定一个字符串 queryIP。如果是有效的 IPv4 地址返回 “IPv4” 如果是有效的 IPv6 地址返回 “IPv6” 如果不是上述类型的 IP 地址返回 “Neither” 。 有效的IPv4地址 是 “x1.x2.x3.x4” 形式的IP地址。 其中 0 xi 255 且 xi 不能包含 前导零。例如: “192.168.1.1” 、 “192.168.1.0” 为有效IPv4地址 “192.168.01.1” 为无效IPv4地址; “192.168.1.00” 、 “192.1681.1” 为无效IPv4地址。 一个有效的IPv6地址 是一个格式为“x1:x2:x3:x4:x5:x6:x7:x8” 的IP地址其中: 1 xi.length 4 xi 是一个 十六进制字符串 可以包含数字、小写英文字母( ‘a’ 到 ‘f’ )和大写英文字母( ‘A’ 到 ‘F’ )。 在 xi 中允许前导零。 例如 “2001:0db8:85a3:0000:0000:8a2e:0370:7334” 和 “2001:db8:85a3:0:0:8A2E:0370:7334” 是有效的 IPv6 地址而 “2001:0db8:85a3::8A2E:037j:7334” 和 “02001:0db8:85a3:0000:0000:8a2e:0370:7334” 是无效的 IPv6 地址。 示例 1 输入queryIP “172.16.254.1” 输出“IPv4” 解释有效的 IPv4 地址返回 “IPv4” 示例 2 输入queryIP “2001:0db8:85a3:0:0:8A2E:0370:7334” 输出“IPv6” 解释有效的 IPv6 地址返回 “IPv6” 示例 3 输入queryIP “256.256.256.256” 输出“Neither” 解释既不是 IPv4 地址又不是 IPv6 地址 class Solution {func validIPAddress(_ queryIP: String) - String {var ipArray queryIP.split(separator: ., omittingEmptySubsequences: false)if ipArray.count 4 {for item in ipArray {if Int(item) nil {return Neither}if Int(item)! 255 {return Neither}if item.count 3 {return Neither}if item.count 1 {if item.hasPrefix(0){return Neither}}}return IPv4}ipArray queryIP.split(separator: :, omittingEmptySubsequences: false)if ipArray.count 8 {for item in ipArray {if item.count 4 || item.count 0 {return Neither}for char in item where !(0 ... 9).contains(char) !(a ... f).contains(char) !(A ... F).contains(char) {return Neither}}return IPv6}return Neither}
}151. 反转字符串中的单词 给你一个字符串 s 请你反转字符串中 单词 的顺序。 单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。 返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。 注意输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中单词间应当仅用单个空格分隔且不包含任何额外的空格。 示例 1 输入s “the sky is blue” 输出“blue is sky the” 示例 2 输入s hello world 输出“world hello” 解释反转后的字符串中不能存在前导空格和尾随空格。 示例 3 输入s “a good example” 输出“example good a” 解释如果两个单词间有多余的空格反转后的字符串需要将单词间的空格减少到仅有一个。 class Solution {func reverseWords(_ s: String) - String {let sArr s.split(separator: ).reversed()return sArr.joined(separator: )}
}686. 重复叠加字符串匹配 给定两个字符串 a 和 b寻找重复叠加字符串 a 的最小次数使得字符串 b 成为叠加后的字符串 a 的子串如果不存在则返回 -1。 注意字符串 “abc” 重复叠加 0 次是 “”重复叠加 1 次是 “abc”重复叠加 2 次是 “abcabc”。 示例 1 输入a “abcd”, b “cdabcdab” 输出3 解释a 重复叠加三遍后为 “abcdabcdabcd”, 此时 b 是其子串。 示例 2 输入a “a”, b “aa” 输出2 示例 3 输入a “a”, b “a” 输出1 示例 4 输入a “abc”, b “wxyz” 输出-1 class Solution {func repeatedStringMatch(_ a: String, _ b: String) - Int {if b.isEmpty {return 0}var newString avar count 1while newString.count b.count {newString acount 1}for _ in 0...1 {if newString.contains(b) {return count}newString acount 1}return -1}
}1764. 通过连接另一个数组的子数组得到一个数组 给你一个长度为 n 的二维整数数组 groups 同时给你一个整数数组 nums 。 你是否可以从 nums 中选出 n 个 不相交 的子数组使得第 i 个子数组与 groups[i] 下标从 0 开始完全相同且如果 i 0 那么第 (i-1) 个子数组在 nums 中出现的位置在第 i 个子数组前面。也就是说这些子数组在 nums 中出现的顺序需要与 groups 顺序相同 如果你可以找出这样的 n 个子数组请你返回 true 否则返回 false 。 如果不存在下标为 k 的元素 nums[k] 属于不止一个子数组就称这些子数组是 不相交 的。子数组指的是原数组中连续元素组成的一个序列。 示例 1 输入groups [[1,-1,-1],[3,-2,0]], nums [1,-1,0,1,-1,-1,3,-2,0] 输出true 解释你可以分别在 nums 中选出第 0 个子数组 [1,-1,0,1,-1,-1,3,-2,0] 和第 1 个子数组 [1,-1,0,1,-1,-1,3,-2,0] 。 这两个子数组是不相交的因为它们没有任何共同的元素。 示例 2 输入groups [[10,-2],[1,2,3,4]], nums [1,2,3,4,10,-2] 输出false 解释选择子数组 [1,2,3,4,10,-2] 和 [1,2,3,4,10,-2] 是不正确的因为它们出现的顺序与 groups 中顺序不同。 [10,-2] 必须出现在 [1,2,3,4] 之前。 示例 3 输入groups [[1,2,3],[3,4]], nums [7,7,1,2,3,4,7,7] 输出false 解释选择子数组 [7,7,1,2,3,4,7,7] 和 [7,7,1,2,3,4,7,7] 是不正确的因为它们不是不相交子数组。 它们有一个共同的元素 nums[4] 下标从 0 开始。 class Solution {func canChoose(_ groups: [[Int]], _ nums: [Int]) - Bool {var index 0var longNumsCount nums.count - 1for groupIndex in 0..groups.count {let group groups[groupIndex]let firstNum group.first!if index longNumsCount {return false}for i in index...longNumsCount {let temp nums[i]if temp firstNum {if i group.count - 1 longNumsCount {var arr:[Int] [Int]()let length i group.countfor j in i..length {arr.append(nums[j])}if arr ! group {index 1} else {index lengthbreak}} else {return false}} else {if i longNumsCount {return false}}}}return true}
}56. 合并区间 以数组 intervals 表示若干个区间的集合其中单个区间为 intervals[i] [starti, endi] 。请你合并所有重叠的区间并返回 一个不重叠的区间数组该数组需恰好覆盖输入中的所有区间 。 示例 1 输入intervals [[1,3],[2,6],[8,10],[15,18]] 输出[[1,6],[8,10],[15,18]] 解释区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6]. 示例 2 输入intervals [[1,4],[4,5]] 输出[[1,5]] 解释区间 [1,4] 和 [4,5] 可被视为重叠区间。 class Solution {func merge(_ intervals: [[Int]]) - [[Int]] {var sortedIntevals intervals.sorted{return $0[0]$1[0]}var lastArr:[Int] [Int]()var newArr:[[Int]] [[Int]]()for index in 0..sortedIntevals.count {let indexArr sortedIntevals[index]if index 0 {lastArr indexArrnewArr.append(lastArr)} else {let lastNum lastArr.last!let nextFistNum indexArr.first!if lastNum nextFistNum {let firstNum min(lastArr.first!, indexArr.first!)let lastNum max(lastNum, indexArr.last!)let mergeArr [firstNum, lastNum]newArr.removeLast()newArr.append(mergeArr)lastArr mergeArr} else {newArr.append(indexArr)lastArr indexArr}}}return newArr}
}229. 多数元素 II 给定一个大小为 n 的整数数组找出其中所有出现超过 ⌊ n/3 ⌋ 次的元素。 示例 1 输入nums [3,2,3] 输出[3] 示例 2 输入nums [1] 输出[1] 示例 3 输入nums [1,2] 输出[1,2] class Solution {func majorityElement(_ nums: [Int]) - [Int] {var repeatDic:[Int:Int] [:]for num in nums {repeatDic[num] (repeatDic[num] ?? 0) 1}let repeatCount Double(nums.count) / 3.0var repeatArr:[Int] [Int]()for (key, value) in repeatDic {if Double(value) repeatCount {repeatArr.append(key)}}return repeatArr}
}347. 前 K 个高频元素 给你一个整数数组 nums 和一个整数 k 请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。 示例 1: 输入: nums [1,1,1,2,2,3], k 2 输出: [1,2] 示例 2: 输入: nums [1], k 1 输出: [1] class Solution {func topKFrequent(_ nums: [Int], _ k: Int) - [Int] {var repeatDic:[Int:Int] [:]for num in nums {repeatDic[num] (repeatDic[num] ?? 0) 1}var valueSortedArr repeatDic.values.sorted { a, b inreturn a b}var minValue 0for i in 0..valueSortedArr.count {if i k {minValue valueSortedArr[i]}}var keyArr:[Int] [Int]()for (key, value) in repeatDic {if value minValue {keyArr.append(key)}}return keyArr}
}
