答案摘抄自：
https://leetcode-cn.com/tag/array/
1002. 查找常用字符
给定仅有小写字母组成的字符串数组 A，返回列表中的每个字符串中都显示的全部字符（包括重复字符）组成的列表。例如，如果一个字符在每个字符串中出现 3 次，但不是 4 次，则需要在最终答案中包含该字符 3 次。
你可以按任意顺序返回答案。
示例 1：
输入：[“bella”,“label”,“roller”]
输出：[“e”,“l”,“l”]
示例 2：
输入：[“cool”,“lock”,“cook”]
输出：[“c”,“o”]
方法：hash 数组
定义一个整形数组 countercounter 记录交集字母出现的次数，下标为 keykey，值为交集字母的次数。
以第零个单词 A[0]A[0] 为基准，确定该单词的字母频次，记录于 countercounter 数组中。
然后从第一个单词 A[1]A[1] 开始遍历，并总结出这些单词的频次，记录于本次遍历的局部变量数组 tempArrtempArr 中。
因为题目要求统计的是所有单词中的出现频次多的字母，所以这些字母必须都在全部单词中出现过才能作为结果的一部分。
以字母 aa 在 A[0] = ccc 和 A[1]=cca 为出现次数为例：
在 A[0]A[0] 中出现 00 次，
在 A[1]A[1] 中出现 11 次。
那么字母 aa 在结果列表中将出现 00 次。
最后把 countercounter 的下标（即 keykey）与字符 aa 的 ASCIIASCII 码相加，转化为具体的字符存入 ListList 中。
综上所述，这本质上是一个在所有单词中求出现频次大于 11 的字母的交集的问题。
public List<String> commonChars(String[] A) {
int[] counter = new int[26];
for(char c : A[0].toCharArray()) // 统计第1个单词各个字母的词频
counter[c - 'a']++;
for (int i = 1; i < A.length; i++) {
int[] tempArr = new int[26];
for (char c : A[i].toCharArray()) {
tempArr[c - 'a']++; // 后一个单词的字母词频
}
for (int j = 0; j < 26; j++) {
if(tempArr[j] < counter[j])
counter[j] = tempArr[j]; // 字母频次的交集
}
}
LinkedList<String> resList = new LinkedList<>();
for (int i = 0; i < 26; i++) {
while (counter[i]-- > 0) { // counter[0] 记录字母a的出现次数
resList.addLast("" + (char)('a' + i));
}
}
return resList;
}
1010. 总持续时间可被 60 整除的歌曲
在歌曲列表中，第 i 首歌曲的持续时间为 time[i] 秒。
返回其总持续时间（以秒为单位）可被 60 整除的歌曲对的数量。形式上，我们希望索引的数字 i < j 且有 (time[i] + time[j]) % 60 == 0。
示例 1：
输入：[30,20,150,100,40]
输出：3
解释：这三对的总持续时间可被 60 整数：
(time[0] = 30, time[2] = 150): 总持续时间 180
(time[1] = 20, time[3] = 100): 总持续时间 120
(time[1] = 20, time[4] = 40): 总持续时间 60
示例 2：
输入：[60,60,60]
输出：3
解释：所有三对的总持续时间都是 120，可以被 60 整数。
方法一：暴力枚举（超时）
对于每一个数字，我的都检查其后面的所有数字，看是否有数字能与本数字组成符合要求的一对数。
public int numPairsDivisibleBy60(int[] time) {
int count = 0;
for (int i = 0; i < time.length; i++) {
for (int j = i + 1; j < time.length; j++)
if ((time[i] + time[j]) % 60 == 0)
count++;
}
return count;
}
复杂度分析：
时间复杂度：O(N^2)，对于每一个数，都要检查其末尾的所有数字。
空间复杂度：O(1)，使用了常数级别的空间。
解法二：取余求差法
其实我们不必没经过一个数字就去检查后面的所有数字，而是采用数组存储每一个数字的补数。这样问题相当于特殊条件的两数之和问题：计算相加后等于 6060 的倍数的数字对的个数。
定义变量 remainder 记录当前余数，大小为60的counter数组计数，从头遍历这个数组[30,20,150,100,40]，我们只需要统计某个数字 time[i] 的之前的数字 60-i 的数量。以下幻灯片体现了整个过程：
public int numPairsDivisibleBy60(int[] time) {
int count = 0;
int[] counter = new int[60];
for (int t : time) {
int remainder = t % 60; //余数
if (remainder == 0)
count += counter[remainder]; //如60,120,180这些只能相互成对。
else if (counter[60-remainder] > 0){
count += counter[60-remainder]; //如30,150
}
counter[remainder]++;
}
return count;
}
复杂度分析：
时间复杂度：O(N)，N 为数组 time 的大小。
空间复杂度：O(1)，使用了常数级别的空间。
1013. 将数组分成和相等的三个部分
给你一个整数数组 A，只有可以将其划分为三个和相等的非空部分时才返回 true，否则返回 false。
形式上，如果可以找出索引 i+1 < j 且满足 (A[0] + A[1] + … + A[i] == A[i+1] + A[i+2] + … + A[j-1] == A[j] + A[j-1] + … + A[A.length - 1]) 就可以将数组三等分。
示例 1：
输出：[0,2,1,-6,6,-7,9,1,2,0,1]
输出：true
解释：0 + 2 + 1 = -6 + 6 - 7 + 9 + 1 = 2 + 0 + 1
示例 2：
输入：[0,2,1,-6,6,7,9,-1,2,0,1]
输出：false
示例 3：
输入：[3,3,6,5,-2,2,5,1,-9,4]
输出：true
解释：3 + 3 = 6 = 5 - 2 + 2 + 5 + 1 - 9 + 4
方法：双指针
数组元素的总和 sum 不是3的倍数，直接返回false
使用双指针left，right, 从数组两头开始一起找，节约时间
当 left + 1 < right 的约束下，可以找到数组两头的和都是 sum/3,那么中间剩下的元素和就一定也是sum/3
（left + 1 < right的约束就是要中间有剩下的元素，使用left < right的约束，数组可能可以恰好被划分成两部分，中间没有元素）
class Solution {
public boolean canThreePartsEqualSum(int[] A) {
int sum = 0;
for(int i : A){
sum += i;
}
if(sum%3 != 0){
// 总和不是3的倍数，直接返回false
return false;
}
// 使用双指针,从数组两头开始一起找，节约时间
int left = 0;
int leftSum = A[left];
int right = A.length - 1;
int rightSum = A[right];
// 使用left + 1 < right 的原因，防止只能将数组分成两个部分
// 例如：[1,-1,1,-1]，使用left < right作为判断条件就会出错
while(left + 1 < right){
if(leftSum == sum/3 && rightSum == sum/3){
// 左右两边都等于 sum/3 ，中间也一定等于
return true;
}
if(leftSum != sum/3){
// left = 0赋予了初值，应该先left++，在leftSum += A[left];
leftSum += A[++left];
}
if(rightSum != sum/3){
// right = A.length - 1 赋予了初值，应该先right--，在rightSum += A[right];
rightSum += A[--right];
}
}
return false;
}
}
1018. 可被 5 整除的二进制前缀
给定由若干 0 和 1 组成的数组 A。我们定义 N_i：从 A[0] 到 A[i] 的第 i 个子数组被解释为一个二进制数（从最高有效位到最低有效位）。
返回布尔值列表 answer，只有当 N_i 可以被 5 整除时，答案 answer[i] 为 true，否则为 false。
示例 1：
输入：[0,1,1]
输出：[true,false,false]
解释：
输入数字为 0, 01, 011；也就是十进制中的 0, 1, 3 。只有第一个数可以被 5 整除，因此 answer[0] 为真。
示例 2：
输入：[1,1,1]
输出：[false,false,false]
示例 3：
输入：[0,1,1,1,1,1]
输出：[true,false,false,false,true,false]
示例 4：
输入：[1,1,1,0,1]
输出：[false,false,false,false,false]
class Solution {
public List<Boolean> prefixesDivBy5(int[] A) {
List<Boolean> res = new ArrayList<Boolean>();
int tail = 0;
for(int i: A) {
tail = tail * 2 + i;
tail = (tail > 9) ? tail - 10 : tail;
if(tail == 0 || tail == 5) {
res.add(true);
} else {
res.add(false);
}
}
return res;
}
}
1160. 拼写单词
给你一份『词汇表』（字符串数组） words 和一张『字母表』（字符串） chars。
假如你可以用 chars 中的『字母』（字符）拼写出 words 中的某个『单词』（字符串），那么我们就认为你掌握了这个单词。
注意：每次拼写时，chars 中的每个字母都只能用一次。
返回词汇表 words 中你掌握的所有单词的 长度之和。
示例 1：
输入：words = [“cat”,“bt”,“hat”,“tree”], chars = “atach”
输出：6
解释：
可以形成字符串 “cat” 和 “hat”，所以答案是 3 + 3 = 6。
示例 2：
输入：words = [“hello”,“world”,“leetcode”], chars = “welldonehoneyr”
输出：10
解释：
可以形成字符串 “hello” 和 “world”，所以答案是 5 + 5 = 10。
方法一：
//统计字符表中各自字符所出现的次数；
//对词汇表中的每个单词也做上述统计；
//比较1,2；如果1中各个字符出现的次数总是大于等于2，则符合要求；
class Solution {
public int countCharacters(String[] words, String chars) {
int[] charsOfCase = new int[26];//统计字符表中的字符
int count = 0;//单词长度之和
for(char c : chars.toCharArray()){//统计字符表中的字符
charsOfCase[c-'a']++;
}
for(String str : words){
int[] temp = new int[26];
boolean flag = true;
for(char c : str.toCharArray()){//存储统计词汇表中单词的字符
temp[c-'a']++;
}
for(int i = 0; i < charsOfCase.length; i++){//对比两个统计数据
if(temp[i] > charsOfCase[i]){
flag = false;
break;
}
}
if(flag) count += str.length();
}
return count;
}
}
方法二：HashMap
class Solution
{
public int countCharacters(String[] words, String chars)
{
if(words.length==0||chars.length()==0)return 0;
char[] ch=chars.toCharArray();
HashMap<Character,Integer> map=new HashMap<>();
int ans=0;
for(char c:ch)
{
map.put(c,map.getOrDefault(c,0)+1);
}
int len=words.length;
for(int i=0;i<=len-1;i++)
{
boolean flag=false;
char[] cc=words[i].toCharArray();
HashMap<Character,Integer> temp=(HashMap)map.clone();
for(int j=0;j<=cc.length-1;j++)
{
if(!map.containsKey(cc[j])){flag=true;break;}//no such,break
else
{
if(temp.get(cc[j])>=1)temp.put(cc[j],temp.get(cc[j])-1);//enough,then -1
else {flag=true;break;}//not enough,break
}
}
if(flag)continue;
ans+=words[i].length();
}
return ans;
}
}
1051. 高度检查器
学校在拍年度纪念照时，一般要求学生按照 非递减 的高度顺序排列。
请你返回能让所有学生以 非递减 高度排列的最小必要移动人数。
注意，当一组学生被选中时，他们之间可以以任何可能的方式重新排序，而未被选中的学生应该保持不动。
示例1：
输入：heights = [1,1,4,2,1,3]
输出：3
解释：
当前数组：[1,1,4,2,1,3]
目标数组：[1,1,1,2,3,4]
在下标 2 处（从 0 开始计数）出现 4 vs 1 ，所以我们必须移动这名学生。
在下标 4 处（从 0 开始计数）出现 1 vs 3 ，所以我们必须移动这名学生。
在下标 5 处（从 0 开始计数）出现 3 vs 4 ，所以我们必须移动这名学生。
示例 2：
输入：heights = [5,1,2,3,4]
输出：5
示例 3：
输入：heights = [1,2,3,4,5]
输出：0
class Solution {
public int heightChecker(int[] heights) {
int[] arr = new int[101];
for (int height : heights) {
arr[height]++;
}
int count = 0;
for (int i = 1, j = 0; i < arr.length; i++) {
while (arr[i]-- > 0) {
if (heights[j++] != i) count++;
}
}
return count;
}
}
1089. 复写零
给你一个长度固定的整数数组 arr，请你将该数组中出现的每个零都复写一遍，并将其余的元素向右平移。
注意：请不要在超过该数组长度的位置写入元素。
要求：请对输入的数组 就地 进行上述修改，不要从函数返回任何东西。
示例 1：
输入：[1,0,2,3,0,4,5,0]
输出：null
解释：调用函数后，输入的数组将被修改为：[1,0,0,2,3,0,0,4]
示例 2：
输入：[1,2,3]
输出：null
解释：调用函数后，输入的数组将被修改为：[1,2,3]
class Solution {
public void duplicateZeros(int[] arr) {
int i = 0 , zero = 0 , l = arr.length-1;
while(i <= l){
if(arr[i] == 0)
zero++;
if(i + zero >= l)
break;
i++;
}
while(i >=0){
arr[l--] = arr[i];
if(arr[i] == 0 && (i + zero <= arr.length-1) )//<=用来判断最后一个如果是0是否超出边界
arr[l--] = arr[i];
i--;
}
}
}
1122. 数组的相对排序
给你两个数组，arr1 和 arr2，
arr2 中的元素各不相同
arr2 中的每个元素都出现在 arr1 中
对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。
示例：
输入：arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
输出：[2,2,2,1,4,3,3,9,6,7,19]
方法：桶排序
class Solution {
public int[] relativeSortArray(int[] arr1, int[] arr2) {
//由于arr1的可能取值为0-1000，共1001个取值，不算一个很大的取值范围，所以可以利用桶式排序
int[] bucket = new int[1001];
//计数每个桶有多少个数，也就是每个值在数组中有几个
for(int num:arr1){
bucket[num]++;
}
//由于重新排序不会改变数组的长度，所以可以利用原数组，可以节省空间复杂度
int i = 0;
//由于排序是按照相对顺序进行排序，所以，首先根据arr2中的桶的顺序，依次从对应的桶中取数到arr1中
//并注意，每拿出一个数，需要将对桶中的数的个数进行-1操作
for(int num:arr2){
while(bucket[num]-- > 0){
arr1[i++] = num;
}
}
//未在arr2中的桶中的数，按照桶号升序进行输出，所以进行二次遍历
for(int j = 0; j < 1001; ++j){
while(bucket[j]-- > 0){
arr1[i++] = j;
}
}
return arr1;
}
}
1287. 有序数组中出现次数超过25%的元素
给你一个非递减的 有序 整数数组，已知这个数组中恰好有一个整数，它的出现次数超过数组元素总数的 25%。
请你找到并返回这个整数
示例：
输入：arr = [1,2,2,6,6,6,6,7,10]
输出：6
方法：双指针
class Solution {
public int findSpecialInteger(int[] arr) {
int before = arr.length / 4 + 1;
for(int i = 0; before < arr.length; i++, before++){
if(arr[i] == arr[before]) return arr[i];
}
return arr[arr.length-1];
}
}
1128. 等价多米诺骨牌对的数量
给你一个由一些多米诺骨牌组成的列表 dominoes。
如果其中某一张多米诺骨牌可以通过旋转 0 度或 180 度得到另一张多米诺骨牌，我们就认为这两张牌是等价的。
形式上，dominoes[i] = [a, b] 和 dominoes[j] = [c, d] 等价的前提是 ac 且 bd，或是 ad 且 bc。
在 0 <= i < j < dominoes.length 的前提下，找出满足 dominoes[i] 和 dominoes[j] 等价的骨牌对 (i, j) 的数量。
示例：
输入：dominoes = [[1,2],[2,1],[3,4],[5,6]]
输出：1
class Solution {
public int numEquivDominoPairs(int[][] dominoes) {
int ans = 0;
int[] cp = new int[100];
for(int[] arr:dominoes){
Arrays.sort(arr);
ans+=cp[arr[0]*10+arr[1]]++;
}
return ans;
}
}
1299. 将每个元素替换为右侧最大元素
给你一个数组 arr ，请你将每个元素用它右边最大的元素替换，如果是最后一个元素，用 -1 替换。
完成所有替换操作后，请你返回这个数组。
示例：
输入：arr = [17,18,5,4,6,1]
输出：[18,6,6,6,1,-1]
方法：逆序遍历
从右往左遍历，先记录右边最大值 rightMax 为最后一个值，向左每次更新 rightMax，使用变量 t 先记住当前 arr[i] 就可以了。
class Solution {
public int[] replaceElements(int[] arr) {
int rightMax = arr[arr.length - 1];
arr[arr.length - 1] = -1;
for (int i = arr.length - 2; i >= 0; i--) {
int t = arr[i];
arr[i] = rightMax;
if (t > rightMax)
rightMax = t;
}
return arr;
}
}
1313. 解压缩编码列表
给你一个以行程长度编码压缩的整数列表 nums 。
考虑每对相邻的两个元素 freq, val] = [nums[2i], nums[2i+1]] （其中 i >= 0 ），每一对都表示解压后子列表中有 freq 个值为 val 的元素，你需要从左到右连接所有子列表以生成解压后的列表。
请你返回解压后的列表。
示例：
输入：nums = [1,2,3,4]
输出：[2,4,4,4]
解释：第一对 [1,2] 代表着 2 的出现频次为 1，所以生成数组 [2]。
第二对 [3,4] 代表着 4 的出现频次为 3，所以生成数组 [4,4,4]。
最后将它们串联到一起 [2] + [4,4,4] = [2,4,4,4]。
示例 2：
输入：nums = [1,1,2,3]
输出：[1,3,3]
解题思路：
//难点在于声明返回数组的大小;
//为了得到返回数组的大小,首先遍历一遍数组nums,计算索引为偶数的数字之和得到返回数组的大小len;
//声明返回数组result的大小为len;
//再遍历一遍数组,进行解码,解码原则为—索引为奇数i的数字nums[i]重复nums[i-1]次,并依次放入返回数组result中;
//最后返回out;
class Solution {
public int[] decompressRLElist(int[] nums) {
int i=0;
int len=0;
while(i<nums.length){
len+= nums[i];
i+=2;
}
int[] result = new int[len];
int index=0;
i=0;
while(i<nums.length){
for(int k=0;k<nums[i];k++){
result[index]=nums[i+1];
index++;
}
i+=2;
}
return result;
}
}
1331. 数组序号转换
给你一个整数数组 arr ，请你将数组中的每个元素替换为它们排序后的序号。
序号代表了一个元素有多大。序号编号的规则如下：
序号从 1 开始编号。
一个元素越大，那么序号越大。如果两个元素相等，那么它们的序号相同。
每个数字的序号都应该尽可能地小。
示例 1：
输入：arr = [40,10,20,30]
输出：[4,1,2,3]
解释：40 是最大的元素。 10 是最小的元素。 20 是第二小的数字。 30 是第三小的数字。
示例 2：
输入：arr = [100,100,100]
输出：[1,1,1]
解释：所有元素有相同的序号。
示例 3：
输入：arr = [37,12,28,9,100,56,80,5,12]
输出：[5,3,4,2,8,6,7,1,3]
class Solution {
public int[] arrayRankTransform(int[] arr) {
// 1. 边界条件判断
if (arr == null || arr.length == 0) {
return arr;
}
// 2. 去重
Set<Integer> set = new HashSet<>();
for (int i : Arrays.copyOf(arr, arr.length)) {
set.add(i);
}
int[] copy = new int[set.size()];
int index = 0;
for (int i : set) {
copy[index++] = i;
}
// 3. 排序
Arrays.sort(copy);
// 4. 装入Map
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < copy.length; i++) {
map.put(copy[i], i + 1);
}
//5. 得到结果
for (int i = 0; i < arr.length; i++) {
int value = arr[i];
arr[i] = map.get(value);
}
return arr;
}
}
1170. 比较字符串最小字母出现频次
我们来定义一个函数 f(s)，其中传入参数 s 是一个非空字符串；该函数的功能是统计 s 中（按字典序比较）最小字母的出现频次。
例如，若 s = “dcce”，那么 f(s) = 2，因为最小的字母是 “c”，它出现了 2 次。
现在，给你两个字符串数组待查表 queries 和词汇表 words，请你返回一个整数数组 answer 作为答案，其中每个 answer[i] 是满足 f(queries[i]) < f(W) 的词的数目，W 是词汇表 words 中的词。
示例 1：
输入：queries = [“cbd”], words = [“zaaaz”]
输出：[1]
解释：查询 f(“cbd”) = 1，而 f(“zaaaz”) = 3 所以 f(“cbd”) < f(“zaaaz”)。
示例 2：
输入：queries = [“bbb”,“cc”], words = [“a”,“aa”,“aaa”,“aaaa”]
输出：[1,2]
解释：第一个查询 f(“bbb”) < f(“aaaa”)，第二个查询 f(“aaa”) 和 f(“aaaa”) 都 > f(“cc”)。
class Solution {
public int[] numSmallerByFrequency(String[] queries, String[] words) {
int[] result = new int[queries.length];
for (int i = 0; i < queries.length; i++) {
int countMinQuery = countMinCode(queries[i]);
for (String word : words) {
if (countMinQuery < countMinCode(word)) {
result[i] ++;
}
}
}
return result;
}
/**
* 统计最小出现频次
* @param s
* @return
*/
public static int countMinCode(String s) {
char min = s.charAt(0);
int count = 0;
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) < min) {
min = s.charAt(i);
count = 0;
}
if (s.charAt(i) == min) {
count++;
}
}
return count;
}
}
- 公交站间的距离
环形公交路线上有 n 个站，按次序从 0 到 n - 1 进行编号。我们已知每一对相邻公交站之间的距离，distance[i] 表示编号为 i 的车站和编号为 (i + 1) % n 的车站之间的距离。
环线上的公交车都可以按顺时针和逆时针的方向行驶。
返回乘客从出发点 start 到目的地 destination 之间的最短距离。
示例 1：
输入：distance = [1,2,3,4], start = 0, destination = 1
输出：1
解释：公交站 0 和 1 之间的距离是 1 或 9，最小值是 1。
示例 2：
输入：distance = [1,2,3,4], start = 0, destination = 2
输出：3
解释：公交站 0 和 2 之间的距离是 3 或 7，最小值是 3。
示例 3：
输
入：distance = [1,2,3,4], start = 0, destination = 3
输出：4
解释：公交站 0 和 3 之间的距离是 6 或 4，最小值是 4。
解题思路：
求两点之间的距离就只有两种方式，一种是从 start 到 destination，另一种是从 destination 到 start。
求两者的较小者即可。
class Solution {
public int distanceBetweenBusStops(int[] distance, int start, int destination) {
// 记录从 start 到 destination 的距离
int len1 = 0;
// 记录从 destination 到 start 的距离
int len2 = 0;
int cur1 = start;
int cur2 = destination;
while(cur1 != destination) {
// 进行记录
len1 += distance[cur1];
// 更新起点
cur1 = (cur1 + 1) % distance.length;
}
while(cur2 != start) {
// 进行记录
len2 += distance[cur2];
// 更新起点
cur2 = (cur2 + 1) % distance.length;
}
return Math.min(len1, len2);
}
}
1185. 一周中的第几天
给你一个日期，请你设计一个算法来判断它是对应一周中的哪一天。
输入为三个整数：day、month 和 year，分别表示日、月、年。
您返回的结果必须是这几个值中的一个 {“Sunday”, “Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday”, “Saturday”}。
示例 1：
输入：day = 31, month = 8, year = 2019
输出：“Saturday”
示例 2：
输入：day = 18, month = 7, year = 1999
输出：“Sunday”
示例 3：
输入：day = 15, month = 8, year = 1993
输出：“Sunday”
解题思路：
1、设置一个num变量计算总天数
2、计算71年到现在经过的所有年份的天数，闰年366.平年365，加到num中
3、计算1月到现在每个月的总天数，加到num中
4、num中加上day
5、将num转化为星期即可
class Solution {
public String dayOfTheWeek(int day, int month, int year) {
int num=0;
int days[]=new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
//计算年份
for(int i=1971;i<year;i++) {
if(i%4==0&&i%100!=0||i%400==0)
num+=366;
else
num+=365;
}
if(year%4==0&&year%100!=0||year%400==0)
days[1]=29;
for(int i=1;i<month;i++)
{
num+=days[i-1];
}
num+=day;
String[] ans_day=new String[]{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
return ans_day[(num+4)%7];
}
}
1200. 最小绝对差
给你个整数数组 arr，其中每个元素都 不相同。
请你找到所有具有最小绝对差的元素对，并且按升序的顺序返回。
示例 1：
输入：arr = [4,2,1,3]
输出：[[1,2],[2,3],[3,4]]
示例 2：
输入：arr = [1,3,6,10,15]
输出：[[1,3]]
示例 3：
输入：arr = [3,8,-10,23,19,-4,-14,27]
输出：[[-14,-10],[19,23],[23,27]]
class Solution {
public List<List<Integer>> minimumAbsDifference(int[] arr) {
ArrayList<List<Integer>> list=new ArrayList<>();
int min=Integer.MAX_VALUE;
Arrays.sort(arr);
for(int i=0;i<arr.length-1;i++){
if(Math.abs(arr[i]-arr[i+1])<min)
min=Math.abs(arr[i]-arr[i+1]);
}
for (int i = 1; i < arr.length; i++) {
if (Math.abs(arr[i] - arr[i - 1]) == min) {
ArrayList<Integer>list1=new ArrayList<>();
list1.add(arr[i - 1]);
list1.add(arr[i]);
list.add(list1);
}
}
System.out.println(min);
return list;
}
}
1217. 玩筹码
数轴上放置了一些筹码，每个筹码的位置存在数组 chips 当中。
你可以对 任何筹码 执行下面两种操作之一（不限操作次数，0 次也可以）：
将第 i 个筹码向左或者右移动 2 个单位，代价为 0。
将第 i 个筹码向左或者右移动 1 个单位，代价为 1。
最开始的时候，同一位置上也可能放着两个或者更多的筹码。
返回将所有筹码移动到同一位置（任意位置）上所需要的最小代价。
示例 1：
输入：chips = [1,2,3]
输出：1
解释：第二个筹码移动到位置三的代价是 1，第一个筹码移动到位置三的代价是 0，总代价为 1。
示例 2：
输入：chips = [2,2,2,3,3]
输出：2
解释：第四和第五个筹码移动到位置二的代价都是 1，所以最小总代价为 2。
这道题其实就是统计奇数和偶数的个数，并且返回个数较少的。
因为移动2次代价为0，那么可以看成是
1）把全部的奇数移动一个位为偶数，此处不考虑怎么移动，
因为移动为偶数后全部移动到一个地方的步数肯定是偶数，那么不计算代价。
2）把全部的偶数移动一个位为奇数，此处不考虑怎么移动，
因为移动为奇数后全部移动到一个地方的步数肯定是偶数，那么不计算代价。
综上所述，代价就是把奇数/偶数移动为偶数/奇数的代价，
也就是奇数/偶数的个数，那么要想代价最小的话，就看奇数少还是偶数少。
class Solution {
public int minCostToMoveChips(int[] chips) {
int odd = 0,even = 0;
for(int data : chips)
if(data % 2 == 1)
odd++;
else
even++;
return Math.min(odd,even);
}
}
1232. 缀点成线
在一个 XY 坐标系中有一些点，我们用数组 coordinates 来分别记录它们的坐标，其中 coordinates[i] = [x, y] 表示横坐标为 x、纵坐标为 y 的点。
请你来判断，这些点是否在该坐标系中属于同一条直线上，是则返回 true，否则请返回 false。
示例 1：
输入：coordinates = [[1,2],[2,3],[3,4],[4,5],[5,6],[6,7]]
输出：true
示例 2：
输入：coordinates = [[1,1],[2,2],[3,4],[4,5],[5,6],[7,7]]
输出：false
public boolean checkStraightLine(int[][] coordinates) {
int k1 = coordinates[1][0] - coordinates[0][0];
int k2 = coordinates[1][1] - coordinates[0][1];
for(int i = 0; i < coordinates.length - 1; i++) {
if((coordinates[i + 1][0] - coordinates[i][0]) * k2 != (coordinates[i + 1][1] - coordinates[i][1]) * k1) {
return false;
}
}
return true;
}
1252. 奇数值单元格的数目
给你一个 n 行 m 列的矩阵，最开始的时候，每个单元格中的值都是 0。
另有一个索引数组 indices，indices[i] = [ri, ci] 中的 ri 和 ci 分别表示指定的行和列（从 0 开始编号）。
你需要将每对 [ri, ci] 指定的行和列上的所有单元格的值加 1。
请你在执行完所有 indices 指定的增量操作后，返回矩阵中 「奇数值单元格」 的数目。
示例 1：
输入：n = 2, m = 3, indices = [[0,1],[1,1]]
输出：6
解释：最开始的矩阵是 [[0,0,0],[0,0,0]]。
第一次增量操作后得到 [[1,2,1],[0,1,0]]。
最后的矩阵是 [[1,3,1],[1,3,1]]，里面有 6 个奇数。
示例 2：
输入：n = 2, m = 2, indices = [[1,1],[0,0]]
输出：0
解释：最后的矩阵是 [[2,2],[2,2]]，里面没有奇数。
直接记一下行数和列数出现的次数即可。
class Solution {
public int oddCells(int n, int m, int[][] indices) {
int[] row=new int[n];
int[] col=new int[m];
for(int i=0;i<indices.length;i++) {
row[indices[i][0]]++;
col[indices[i][1]]++;
}
int ans=0;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++) {
if((row[i]+col[j])%2>0)
ans++;
}
return ans;
}
}
1266. 访问所有点的最小时间
平面上有 n 个点，点的位置用整数坐标表示 points[i] = [xi, yi]。请你计算访问所有这些点需要的最小时间（以秒为单位）。
你可以按照下面的规则在平面上移动：
每一秒沿水平或者竖直方向移动一个单位长度，或者跨过对角线（可以看作在一秒内向水平和竖直方向各移动一个单位长度）。
必须按照数组中出现的顺序来访问这些点。
示例 1：
输入：points = [[1,1],[3,4],[-1,0]]
输出：7
解释：一条最佳的访问路径是： [1,1] -> [2,2] -> [3,3] -> [3,4] -> [2,3] -> [1,2] -> [0,1] -> [-1,0]
从 [1,1] 到 [3,4] 需要 3 秒
从 [3,4] 到 [-1,0] 需要 4 秒
一共需要 7 秒
示例 2：
输入：points = [[3,2],[-2,2]]
输出：5
class Solution {
public int minTimeToVisitAllPoints(int[][] points) {
int min = 0;
for (int i = 1; i < points.length; ++i)
min += findMinStep(points[i - 1][0], points[i - 1][1], points[i][0], points[i][1]);
return min;
}
private static int findMinStep(int x1, int y1, int x2, int y2) {
int minSlope = Math.min(Math.abs(x1 - x2), Math.abs(y1 - y2));
return Math.abs(x1 - x2) + Math.abs(y1 - y2) - minSlope;
}
}
1.先计算移动到同一行或同一列所需最少步数: Math.min(Math.abs(x1 - x2), Math.abs(y1 - y2))
2.然后计算整体步数: 整体步数 = (x方向移动 - 最小步数) + (y方向移动 - 最小步数) + 最小步数, 化简完即为: Math.abs(x1 - x2) + Math.abs(y1 - y2) - minSlope
1275. 找出井字棋的获胜者
A 和 B 在一个 3 x 3 的网格上玩井字棋。
井字棋游戏的规则如下：
玩家轮流将棋子放在空方格 (" ") 上。
第一个玩家 A 总是用 “X” 作为棋子，而第二个玩家 B 总是用 “O” 作为棋子。
“X” 和 “O” 只能放在空方格中，而不能放在已经被占用的方格上。
只要有 3 个相同的（非空）棋子排成一条直线（行、列、对角线）时，游戏结束。
如果所有方块都放满棋子（不为空），游戏也会结束。
游戏结束后，棋子无法再进行任何移动。
给你一个数组 moves，其中每个元素是大小为 2 的另一个数组（元素分别对应网格的行和列），它按照 A 和 B 的行动顺序（先 A 后 B）记录了两人各自的棋子位置。
如果游戏存在获胜者（A 或 B），就返回该游戏的获胜者；如果游戏以平局结束，则返回 “Draw”；如果仍会有行动（游戏未结束），则返回 “Pending”。
你可以假设 moves 都 有效（遵循井字棋规则），网格最初是空的，A 将先行动。
示例 1：
输入：moves = [[0,0],[2,0],[1,1],[2,1],[2,2]]
输出：“A”
解释：“A” 获胜，他总是先走。
"X " "X " "X " "X " "X "
" " -> " " -> " X " -> " X " -> " X "
" " "O " "O " "OO " “OOX”
示例 2：
输入：moves = [[0,0],[1,1],[0,1],[0,2],[1,0],[2,0]]
输出：“B”
解释：“B” 获胜。
"X " "X " "XX " “XXO” “XXO” “XXO”
" " -> " O " -> " O " -> " O " -> "XO " -> "XO "
" " " " " " " " " " "O "
示例 3：
输入：moves = [[0,0],[1,1],[2,0],[1,0],[1,2],[2,1],[0,1],[0,2],[2,2]]
输出：“Draw”
输出：由于没有办法再行动，游戏以平局结束。
“XXO”
“OOX”
“XOX”
示例 4：
输入：moves = [[0,0],[1,1]]
输出：“Pending”
解释：游戏还没有结束。
"X "
" O "
" "
public String tictactoe(int[][] moves) {
int m = moves.length;
// 用数组记录0-2行、0-2列、正对角线、副对角线是否已满3个棋子
// count[0-2]对应0-2行、count[3-5]对应0-2列、count[6]对应正对角线、count[7]对应副对角线
int[] count = new int[8];
// 思路第2步已解释为何只需考虑最后一个落棋的人
// 倒序统计此人走棋情况
for(int i = m - 1; i >= 0; i -= 2) {
// 此棋对行的影响
count[moves[i][0]]++;
// 此棋对列的影响
count[moves[i][1] + 3]++;
// 此棋对正对角线的影响
if(moves[i][0] == moves[i][1])
count[6]++;
// 此棋对副对角线的影响 (
// 此处为3x3的情况，其余大小的棋盘可以类推
if(moves[i][0] + moves[i][1] == 2)
count[7]++;
// 满3个棋子则胜利
if(count[moves[i][0]] == 3 || count[moves[i][1] + 3] == 3 ||
count[6] == 3 || count[7] == 3)
// A先B后 则总长度为偶时 最后为B 反之为A
return m % 2 == 0 ? "B" : "A";
}
// 未胜时，棋盘未下满则继续
if(moves.length < 9)
return "Pending";
// 未胜时，棋盘下满则平局结束
return "Draw";
}
1295. 统计位数为偶数的数字
给你一个整数数组 nums，请你返回其中位数为 偶数 的数字的个数。
示例 1：
输入：nums = [12,345,2,6,7896]
输出：2
解释：
12 是 2 位数字（位数为偶数）
345 是 3 位数字（位数为奇数）
2 是 1 位数字（位数为奇数）
6 是 1 位数字 位数为奇数）
7896 是 4 位数字（位数为偶数）
因此只有 12 和 7896 是位数为偶数的数字
示例 2：
输入：nums = [555,901,482,1771]
输出：1
解释：
只有 1771 是位数为偶数的数字。
解题思路:
将int转为String，调用.length，然后%2==0即为偶数
class Solution {
public int findNumbers(int[] nums) {
int res=0;
for(int i:nums){
if(String.valueOf(i).length()%2==0){
res++;
}
}
return res;
}
}
1304. 和为零的N个唯一整数
给你一个整数 n，请你返回 任意 一个由 n 个 各不相同 的整数组成的数组，并且这 n 个数相加和为 0 。
示例 1：
输入：n = 5
输出：[-7,-1,1,3,4]
解释：这些数组也是正确的 [-5,-1,1,2,3]，[-3,-1,2,-2,4]。
示例 2：
输入：n = 3
输出：[-1,0,1]
示例 3：
输入：n = 1
输出：[0]
方法一：枚举
public int[] sumZero(int n) {
int sum = 0;
int[] arr = new int[n];
int len = 0;
for (int i = 0; i <= n - 2; i++) {
arr[len++] = i;
sum += i;
}
arr[len] = -sum;
return arr;
}
方法二：双指针迭代
public int[] sumZero(int n) {
int[] arr = new int[n];
int l = 0, r = n-1; //左边界与右边界
int i = 1;
while (l < r) {
arr[l++] = i;
arr[r--] = -i;
i++;
}
return arr;
}
1337. 方阵中战斗力最弱的 K 行
给你一个大小为 m * n 的方阵 mat，方阵由若干军人和平民组成，分别用 0 和 1 表示。
请你返回方阵中战斗力最弱的 k 行的索引，按从最弱到最强排序。
如果第 i 行的军人数量少于第 j 行，或者两行军人数量相同但 i 小于 j，那么我们认为第 i 行的战斗力比第 j 行弱。
军人 总是 排在一行中的靠前位置，也就是说 1 总是出现在 0 之前。
示例 1：
输入：mat =
[[1,1,0,0,0],
[1,1,1,1,0],
[1,0,0,0,0],
[1,1,0,0,0],
[1,1,1,1,1]],
k = 3
输出：[2,0,3]
解释：
每行中的军人数目：
行 0 -> 2
行 1 -> 4
行 2 -> 1
行 3 -> 2
行 4 -> 5
从最弱到最强对这些行排序后得到 [2,0,3,1,4]
示例 2：
输入：mat =
[[1,0,0,0],
[1,1,1,1],
[1,0,0,0],
[1,0,0,0]],
k = 2
输出：[0,2]
解释：
每行中的军人数目：
行 0 -> 1
行 1 -> 4
行 2 -> 1
行 3 -> 1
从最弱到最强对这些行排序后得到 [0,2,3,1]
public int[] kWeakestRows(int[][] mat, int k) {
int[][] tmp = new int[mat.length][2];
for(int i = 0; i < mat.length; i++){
for(int j = 0; j < mat[0].length; j++){
tmp[i][0] = i;
if(mat[i][j] == 1) tmp[i][1] += 1;
}
}
Arrays.sort(tmp, (o1, o2) -> o1[1] - o2[1]);
int[] res = new int[k];
for(int i =0; i < k; i++){
res[i] = tmp[i][0];
}
return res;
}
1346. 检查整数及其两倍数是否存在
给你一个整数数组 arr，请你检查是否存在两个整数 N 和 M，满足 N 是 M 的两倍（即，N = 2 * M）。
更正式地，检查是否存在两个下标 i 和 j 满足：
i != j
0 <= i, j < arr.length
arr[i] == 2 * arr[j]
示例 1：
输入：arr = [10,2,5,3]
输出：true
解释：N = 10 是 M = 5 的两倍，即 10 = 2 * 5 。
示例 2：
输入：arr = [7,1,14,11]
输出：true
解释：N = 14 是 M = 7 的两倍，即 14 = 2 * 7 。
示例 3：
输入：arr = [3,1,7,11]
输出：false
解释：在该情况下不存在 N 和 M 满足 N = 2 * M 。
方法：HashMap
前提设定：
用HashMap<Integer,Integer> map存放遍历arr时当前tempNum的<2倍值,tempNum>和<1/2倍值,tempNum>（若tempNum为偶数），注意，2tempNum、1/2tempNum均作为key值。
遍历开始：
- 查看map中是否存在key==tempNum的键值对，是：转2；否：转3；
- 返回true（表明已遍历的元素中存在tempNum1/2或tempNum2）；
- 将<tempNum*2,tempNum>添加到map，若tempNum为偶数，再将<tempNum/2,tempNum>添加到map;
- 遍历结束，程序仍未返回，说明不存在一个整数是另外一个整数的两倍，返回false;
注：
- 此解中map中的value无关紧要，也可存放当前遍历元素的索引值；
- 进阶：若题目改为：返回所有构成2倍关系的数组元素的索引对，或元素对，即可直接将上述方法中map的value改为index，返回值改为<i,map.get(tempNum)> 或 <arr[i],arr[map.get(tempNum)]>;
class Solution {
public boolean checkIfExist(int[] arr) {
Map<Integer,Integer> map = new HashMap<>();
for(int tempInt : arr){
//Integer tempRst = map.get(tempInt);
if(map.keySet().contains(tempInt)){
return true;
}else{
map.put(tempInt*2,tempInt);
if(tempInt%2 == 0){
map.put(tempInt/2,tempInt);
}
}
}
return false;
}
}
1351. 统计有序矩阵中的负数
给你一个 m * n 的矩阵 grid，矩阵中的元素无论是按行还是按列，都以非递增顺序排列。
请你统计并返回 grid 中 负数 的数目。
示例 1：
输入：grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]
输出：8
解释：矩阵中共有 8 个负数。
示例 2：
输入：grid = [[3,2],[1,0]]
输出：0
示例 3：
输入：grid = [[1,-1],[-1,-1]]
输出：3
示例 4：
输入：grid = [[-1]]
输出：1
方法：非递增序列，遇到负数，该 行/列 后面就全是负数
class Solution {
public int countNegatives(int[][] grid) {
int cnt = 0;
for(int i=0;i<grid.length;i++){
//按列非递增
if(grid[i][0]<0){
cnt += (grid.length-i)*grid[0].length;
break;
}
for(int j=0;j<grid[i].length;j++){
//按行非递增
if(grid[i][j]<0){
cnt += grid[i].length-j;
break;
}
}
}
return cnt;
}
}
1365. 有多少小于当前数字的数字
给你一个数组 nums，对于其中每个元素 nums[i]，请你统计数组中比它小的所有数字的数目。
换而言之，对于每个 nums[i] 你必须计算出有效的 j 的数量，其中 j 满足 j != i 且 nums[j] < nums[i] 。
以数组形式返回答案。
示例 1：
输入：nums = [8,1,2,2,3]
输出：[4,0,1,1,3]
解释：
对于 nums[0]=8 存在四个比它小的数字：（1，2，2 和 3）。
对于 nums[1]=1 不存在比它小的数字。
对于 nums[2]=2 存在一个比它小的数字：（1）。
对于 nums[3]=2 存在一个比它小的数字：（1）。
对于 nums[4]=3 存在三个比它小的数字：（1，2 和 2）。
示例 2：
输入：nums = [6,5,4,8]
输出：[2,1,0,3]
示例 3：
输入：nums = [7,7,7,7]
输出：[0,0,0,0]
解题思路：
temp[]数组的作用是先将nums[]排序，最后temp[]返回结果
排序后每个元素的索引为小于等于这个元素的元素数量，我们需要单独处理相邻元素相等的情况
只需要将相邻相等元素的value设为相等即可
class Solution {
public int[] smallerNumbersThanCurrent(int[] nums) {
int n = nums.length;
int[] temp = new int[n];
temp = Arrays.copyOf(nums, n);
Arrays.sort(temp);
Map<Integer, Integer> map = new HashMap<>();
for(int i = 0; i < n; i++){
if(i == 0){
map.put(temp[i],0);
}else{
if(temp[i] > temp[i-1]){
map.put(temp[i],i);
}else{
map.put(temp[i],map.get(temp[i-1]));
}
}
}
for(int i = 0; i < n; i++){
temp[i] = map.get(nums[i]);
}
return temp;
}
}
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
