LeetCode-Kotlin-Array-EASY-21至30题

关键字

PriorityQueue
Pair
HashMap和HashSet的区别

1.HashMap实现了Map接口，而HashSet实现了Set接口。

2.HashMap用于存储键值对，而HashSet用于存储对象。

3.HashMap不允许有重复的键，可以允许有重复的值。HashSet不允许有重复元素。

4.HashMap允许有一个键为空，多个值为空，HashSet允许有一个空值。

5.HashMap中使用put()将元素加入map中，而HashSet使用add()将元素放入set中。

6.HashMap比较快，因为其使用唯一的键来获取对象。

21.Teemo Attacking

题目大意

在《英雄联盟》的世界中，有一个叫 “提莫” 的英雄。他的攻击可以让敌方英雄艾希（编者注：寒冰射手）进入中毒状态。

当提莫攻击艾希，艾希的中毒状态正好持续duration 秒。

正式地讲，提莫在t发起发起攻击意味着艾希在时间区间 [t, t + duration - 1]（含 t 和 t + duration - 1）处于中毒状态。

如果提莫在中毒影响结束前再次攻击，中毒状态计时器将会重置，在新的攻击之后，中毒影响将会在duration秒后结束。

给你一个非递减的整数数组timeSeries，其中timeSeries[i]表示提莫在timeSeries[i]秒时对艾希发起攻击，以及一个表示中毒持续时间的整数duration 。

返回艾希处于中毒状态的总秒数。

解题思路

i 从 1 开始计数，令 t 等于 timeSeries[i - 1]
比较 end(t + duration - 1) 和 timeSeries[i] 的大小，
如果 end 小于 timeSeries[i],ans+=duration
否则 ans += timeSeries[i] - t
ans += duration 并返回 ans

代码

 var timeSeries = intArrayOf(1, 4)
 var duration = 2
 println(findPoisonedDuration(timeSeries, duration))

fun findPoisonedDuration(timeSeries: IntArray, duration: Int): Int {
    if (timeSeries.isEmpty() || duration == 0) return 0
    var result = 0
    var start = timeSeries[0]
    var end = timeSeries[0] + duration
    for (value in timeSeries) {
        if (value > end) {
            result += end - start
            start = value
        }
        end = value + duration
    }
    result += end - start
    return result
}

22.Next Greater Element I

题目大意

这道题也是简单题。题目给出 2 个数组 A 和 B，针对 A 中的每个数组中的元素，要求在 B 数组中找出比 A 数组中元素大的数，B 中元素之间的顺序保持不变。如果找到了就输出这个值，如果找不到就输出 -1。

代码

 var nums1 = intArrayOf(4, 1, 2)
    var nums2 = intArrayOf(1, 3, 4, 2)
    println(nextGreaterElement(nums1, nums2).mapIndexed { index, i -> i })

fun nextGreaterElement(findNums: IntArray, nums: IntArray): IntArray {
    var map = HashMap<Int, Int>()
    var stack = Stack<Int>()
    for (num in nums) {
        while (!stack.isEmpty() && stack.peek() < num) {
            map[stack.pop()] = num
        }
        stack.push(num)
    }
    for (i in findNums.indices) {
        findNums[i] = map.getOrDefault(findNums[i], -1)
    }
    return findNums
}

[-1, 3, -1]

23.Keyboard Row

题目大意

给定一个单词列表，只返回可以使用在键盘同一行的字母打印出来的单词。键盘如上图所示。

解题思路

给出一个字符串数组，要求依次判断数组中的每个字符串是否都位于键盘上的同一个行，如果是就输出

代码

var words = arrayOf("Hello", "Alaska", "Dad", "Peace")
 println(findWords(words).toMutableList())

fun findWords(words: Array<String>): Array<String> {
    var strs = arrayOf("QWERTYUIOP", "ASDFGHJKL", "ZXCVBNM")
    var map = HashMap<Char, Int>()
    for (i in strs.indices) {
        for (c in strs[i].toCharArray()) {
            map[c] = i
        }
    }
    var res = LinkedList<String>()
    for (w in words) {
        if (w == "") continue
        var index = map[w.toUpperCase()[0]]
        for (c in w.toUpperCase().toCharArray()) {
            if (map[c] != index) {
                index = -1
                break
            }
        }
        if (index != -1) res.add(w)
    }
    return res.toTypedArray()
}

[Alaska, Dad]

24.Relative Ranks

题目大意

给你一个长度为 n 的整数数组 score ，其中 score[i] 是第 i 位运动员在比赛中的得分。所有得分都互不相同。

运动员将根据得分决定名次，其中名次第 1 的运动员得分最高，名次第 2 的运动员得分第 2 高，依此类推。运动员的名次决定了他们的获奖情况：

名次第 1 的运动员获金牌 “Gold Medal” 。
名次第 2 的运动员获银牌 “Silver Medal” 。
名次第 3 的运动员获铜牌 “Bronze Medal” 。
从名次第 4 到第 n 的运动员，只能获得他们的名次编号（即，名次第 x 的运动员获得编号 “x”）。

使用长度为 n 的数组 answer 返回获奖，其中 answer[i] 是第 i 位运动员的获奖情况。

解题思路

用 map 记录原来 score 中元素对应的坐标，然后对 score 进行排序，对排序后的元素我们通过 map 就可以知道它排的名次了

代码

 var score = intArrayOf(10, 2, 8, 9, 4)
    println(priorityQueueSol(score))

fun priorityQueueSol(score: IntArray): Array<String> {
    val queue = PriorityQueue<Pair<Int, Int>>(score.size, Comparator<Pair<Int, Int>> { o1, o2 ->
        o2.first.compareTo(o1.first)
    })

    score.forEachIndexed { i, sc ->
        queue.add(Pair(sc, i))
    }
    //queue:[(10, 0), (9, 3), (8, 2), (2, 1), (4, 4)]
  
    val result = Array<String>(score.size) { "" }
    var i = 0
    while(!queue.isEmpty()) {
        val pair = queue.poll()
        result[pair.second] = when(i+1) {
            1 -> "Gold Medal"
            2 -> "Silver Medal"
            3 -> "Bronze Medal"
            else -> (i+1).toString()
        }

        i++
    }

    return result
}

[Gold Medal, 5, Bronze Medal, Silver Medal, 4]

25. Array Partition

题目大意

给定长度为 2n 的数组, 你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), …, (an, bn) ，使得从1 到 n 的 min(ai, bi) 总和最大。

解题思路

给定一个 2n 个数组，要求把它们分为 n 组一行，求出各组最小值的总和的最大值。
在这里插入图片描述

代码

  var nums = intArrayOf(1, 4, 3, 2)
    println(arrayPairSum(nums))

fun arrayPairSum(nums: IntArray): Int {
    nums.sort()
    var result = 0
    for (i in nums.indices.step(2)){
        result+=nums[i]
    }
    return result
}

26.Reshape the Matrix

题目大意

在 MATLAB 中，有一个非常有用的函数 reshape，它可以将一个矩阵重塑为另一个大小不同的新矩阵，但保留其原始数据。

给出一个由二维数组表示的矩阵，以及两个正整数r和c，分别表示想要的重构的矩阵的行数和列数。重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。如果具有给定参数的reshape操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。
在这里插入图片描述

解题思路

给一个二维数组和 r，c，将这个二维数组“重塑”成行为 r，列为 c。如果可以“重塑”，输出“重塑”以后的数组，如果不能“重塑”，输出原有数组。

代码

 var nums = arrayOf(intArrayOf(1, 2), intArrayOf(3, 4))
    println(matrixReshape(nums, 1, 4).mapIndexed { index, ints -> ints.toMutableList() })

fun matrixReshape(mat: Array<IntArray>, r: Int, c: Int): Array<IntArray> {
    if (r * c != mat.size * mat[0].size) {
        return mat
    }
    var list = mutableListOf<Int>()
    for (i in mat) {
        for (j in i) list.add(j)
    }
    //list:[1, 2, 3, 4]
    var currentIndex = 0
    val new = Array(r) { IntArray(c) }
    for (i in new.indices) {
        val row = new[i]
        for (j in row.indices) {
            new[i][j] = list[currentIndex]
            currentIndex++
        }
    }
    return new
}

[[1, 2, 3, 4]]

Given an integer array with even length, where different numbers in this array represent different kinds of candies. Each number means one candy of the corresponding kind. You need to distribute these candies equally in number to brother and sister. Return the maximum number of kinds of candies the sister could gain.

Example 1:

Input: candies = [1,1,2,2,3,3]
Output: 3
Explanation:
There are three different kinds of candies (1, 2 and 3), and two candies for each kind.
Optimal distribution: The sister has candies [1,2,3] and the brother has candies [1,2,3], too.
The sister has three different kinds of candies.

Example 2:

Input: candies = [1,1,2,3]
Output: 2
Explanation: For example, the sister has candies [2,3] and the brother has candies [1,1].
The sister has two different kinds of candies, the brother has only one kind of candies.

Note:

The length of the given array is in range [2, 10,000], and will be even.
The number in given array is in range [-100,000, 100,000].

题目大意 #

给定一个偶数长度的数组，其中不同的数字代表着不同种类的糖果，每一个数字代表一个糖果。你需要把这些糖果平均分给一个弟弟和一个妹妹。返回妹妹可以获得的最大糖果的种类数。

解题思路

给出一个糖果数组，里面每个元素代表糖果的种类，相同数字代表相同种类。把这些糖果分给兄弟姐妹，问姐妹最多可以分到多少种糖果。这一题比较简单，用 map 统计每个糖果的出现频次，如果总数比 n/2 小，那么就返回 len(map)，否则返回 n/2 (即一半都分给姐妹)。

代码

var nums = intArrayOf(1, 1, 2, 3)
println(distributeCandies(nums))

fun distributeCandies(candies: IntArray): Int {
    var kinds = HashSet<Int>()
    for (candy in candies) {
        kinds.add(candy)
    }
    return if (kinds.size >= candies.size / 2) candies.size / 2 else kinds.size
}

28.Longest Harmonious Subsequence

题目大意

和谐数组是指一个数组里元素的最大值和最小值之间的差别正好是1。现在，给定一个整数数组，你需要在所有可能的子序列中找到最长的和谐子序列的长度。说明: 输入的数组长度最大不超过20,000.

解题思路

在给出的数组里面找到这样一个子数组：要求子数组中的最大值和最小值相差 1 。这一题是简单题。先统计每个数字出现的频次，然后在 map 找相差 1 的 2 个数组的频次和，动态的维护两个数的频次和就是最后要求的子数组的最大长度。

代码

 var nums = intArrayOf(1, 3, 2, 2, 5, 2, 3, 7)
 println(findLHS(nums))


fun findLHS(nums: IntArray): Int {
    var m = HashMap<Int, Int>()
    for (num in nums){
        m.put(num,m.getOrDefault(num,0)+1)
    }
    var max=0
    for ( i in m.keys){
        if (m.containsKey(i+1)) max=Math.max(max,m.get(i)!!+ m.get(i+1)!!)
    }
    return max
}

5 [3,2,2,2,3]

29.Range Addition II

题目大意

给定一个初始元素全部为 0，大小为 m*n 的矩阵 M 以及在 M 上的一系列更新操作。操作用二维数组表示，其中的每个操作用一个含有两个正整数 a 和 b 的数组表示，含义是将所有符合 0 <= i < a 以及 0 <= j < b 的元素 M[i][j] 的值都增加 1。在执行给定的一系列操作后，你需要返回矩阵中含有最大整数的元素个数。

注意:

m 和 n 的范围是 [1,40000]。
a 的范围是 [1,m]，b 的范围是 [1,n]。
操作数目不超过 10000。

在这里插入图片描述

解题思路

给定一个初始都为 0 的 m * n 的矩阵，和一个操作数组。经过一系列的操作以后，最终输出矩阵中最大整数的元素个数。每次操作都使得一个矩形内的元素都 + 1 。
这一题乍一看像线段树的区间覆盖问题，但是实际上很简单。如果此题是任意的矩阵，那就可能用到线段树了。这一题每个矩阵的起点都包含 [0 , 0] 这个元素，也就是说每次操作都会影响第一个元素。那么这道题就很简单了。经过 n 次操作以后，被覆盖次数最多的矩形区间，一定就是最大整数所在的区间。由于起点都是第一个元素，所以我们只用关心矩形的右下角那个坐标。右下角怎么计算呢？只用每次动态的维护一下矩阵长和宽的最小值即可。

代码

    var m = 3
    var n = 3
    var ops = arrayOf(intArrayOf(2, 2), intArrayOf(3, 3))
    println(maxCount(m, n, ops))

fun maxCount(m: Int, n: Int, ops: Array<IntArray>): Int {
    if (ops.isEmpty()) return m * n
    var row=Int.MAX_VALUE
    var col=Int.MAX_VALUE
    for (item in ops){
        row= min(row,item[0])
        col = min(col,item[1])
    }
    return  row * col
}

30.Minimum Index Sum of Two Lists

题目大意

假设 Andy 和 Doris 想在晚餐时选择一家餐厅，并且他们都有一个表示最喜爱餐厅的列表，每个餐厅的名字用字符串表示。你需要帮助他们用最少的索引和找出他们共同喜爱的餐厅。如果答案不止一个，则输出所有答案并且不考虑顺序。你可以假设总是存在一个答案。

提示:

两个列表的长度范围都在 [1, 1000] 内。
两个列表中的字符串的长度将在 [1，30] 的范围内。
下标从 0 开始，到列表的长度减 1。
两个列表都没有重复的元素。

解题思路

在 Andy 和 Doris 两人分别有各自的餐厅喜欢列表，要求找出两人公共喜欢的一家餐厅，如果共同喜欢的次数相同，都输出。这一题是简单题，用 map 统计频次，输出频次最多的餐厅。

代码

    var list1 = arrayOf("Shogun", "Tapioca Express", "Burger King", "KFC")
    var list2 = arrayOf("KFC", "Shogun", "Burger King")
    println(findRestaurant(list1, list2).toMutableList())

fun findRestaurant(list1: Array<String>, list2: Array<String>): Array<String?> {
    if (list1.size > list2.size) {
        return findRestaurant(list2, list1)
    }

    val map1: MutableMap<String, Int> = HashMap()
    for (i in list1.indices) {
        map1[list1[i]] = i
    }

    var mins: MutableList<String?> = ArrayList()
    var minSum = Int.MAX_VALUE
    for (i in list2.indices) {
        val rest2 = list2[i]
        if (map1.containsKey(rest2)) {
            val sum = map1[rest2]!! + i
            if (sum < minSum) {
                mins = ArrayList()
                minSum = sum
            }
            if (sum == minSum) {
                mins.add(rest2)
            }
        }
    }

    return mins.toTypedArray()
}