1165-1176-1180-1228-1243-1271-1426-1564-1708 (9)

Author: gdut-yy

leetcode-12/src/main/java/Solution1165.java

@@ -0,0 +1,34 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution1165 {
+    public int calculateTime(String keyboard, String word) {
+        Map<Character, Integer> idxMap = new HashMap<>();
+        for (int i = 0; i < 26; i++) {
+            idxMap.put(keyboard.charAt(i), i);
+        }
+
+        int res = 0;
+        char pre = keyboard.charAt(0);
+        for (char ch : word.toCharArray()) {
+            res += Math.abs(idxMap.get(ch) - idxMap.get(pre));
+            pre = ch;
+        }
+        return res;
+    }
+}
+/*
+$1165. 单行键盘
+https://leetcode.cn/problems/single-row-keyboard/
+
+我们定制了一款特殊的键盘，所有的键都 排列在一行上 。
+给定一个长度为 26 的字符串 keyboard ，来表示键盘的布局(索引从 0 到 25 )。一开始，你的手指在索引 0 处。要输入一个字符，你必须把你的手指移动到所需字符的索引处。手指从索引 i 移动到索引 j 所需要的时间是 |i - j|。
+您需要输入一个字符串 word 。写一个函数来计算用一个手指输入需要多少时间。
+提示：
+keyboard.length == 26
+keyboard 按某种特定顺序排列，并包含每个小写英文字母一次。
+1 <= word.length <= 104
+word[i] 为小写英文字母
+
+HashMap模拟
+ */

leetcode-12/src/main/java/Solution1176.java

@@ -0,0 +1,39 @@
+public class Solution1176 {
+    public int dietPlanPerformance(int[] calories, int k, int lower, int upper) {
+        int len = calories.length;
+        int[] preSum = new int[len + 1];
+        for (int i = 0; i < len; i++) {
+            preSum[i + 1] = preSum[i] + calories[i];
+        }
+
+        int res = 0;
+        for (int i = 0; i + k <= len; i++) {
+            int T = preSum[i + k] - preSum[i];
+            if (T < lower) {
+                res--;
+            } else if (T > upper) {
+                res++;
+            }
+        }
+        return res;
+    }
+}
+/*
+$1176. 健身计划评估
+https://leetcode.cn/problems/diet-plan-performance/
+
+你的好友是一位健身爱好者。前段日子，他给自己制定了一份健身计划。现在想请你帮他评估一下这份计划是否合理。
+他会有一份计划消耗的卡路里表，其中 calories[i] 给出了你的这位好友在第 i 天需要消耗的卡路里总量。
+为了更好地评估这份计划，对于卡路里表中的每一天，你都需要计算他 「这一天以及之后的连续几天」 （共 k 天）内消耗的总卡路里 T：
+- 如果 T < lower，那么这份计划相对糟糕，并失去 1 分；
+- 如果 T > upper，那么这份计划相对优秀，并获得 1 分；
+- 否则，这份计划普普通通，分值不做变动。
+请返回统计完所有 calories.length 天后得到的总分作为评估结果。
+注意：总分可能是负数。
+提示：
+1 <= k <= calories.length <= 10^5
+0 <= calories[i] <= 20000
+0 <= lower <= upper
+
+前缀和 + 模拟
+ */

leetcode-12/src/main/java/Solution1180.java

@@ -0,0 +1,40 @@
+public class Solution1180 {
+    public int countLetters(String s) {
+        int res = 0;
+        int cnt = 0;
+        char pre = ' ';
+        for (char ch : s.toCharArray()) {
+            if (ch != pre) {
+                cnt = 1;
+            } else {
+                cnt++;
+            }
+            res += cnt;
+            pre = ch;
+        }
+        return res;
+    }
+}
+/*
+$1180. 统计只含单一字母的子串
+https://leetcode.cn/problems/count-substrings-with-only-one-distinct-letter/
+
+给你一个字符串 s，返回 只含 单一字母 的子串个数 。
+示例 1：
+输入： s = "aaaba"
+输出： 8
+解释： 只含单一字母的子串分别是 "aaa"， "aa"， "a"， "b"。
+"aaa" 出现 1 次。
+"aa" 出现 2 次。
+"a" 出现 4 次。
+"b" 出现 1 次。
+所以答案是 1 + 2 + 4 + 1 = 8。
+示例 2:
+输入： s = "aaaaaaaaaa"
+输出： 55
+提示：
+1 <= s.length <= 1000
+s[i] 仅由小写英文字母组成
+
+计数
+ */

leetcode-12/src/test/java/Solution1165Tests.java

@@ -0,0 +1,22 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1165Tests {
+    private final Solution1165 solution1165 = new Solution1165();
+
+    @Test
+    public void example1() {
+        String keyboard = "abcdefghijklmnopqrstuvwxyz";
+        String word = "cba";
+        int expected = 4;
+        Assertions.assertEquals(expected, solution1165.calculateTime(keyboard, word));
+    }
+
+    @Test
+    public void example2() {
+        String keyboard = "pqrstuvwxyzabcdefghijklmno";
+        String word = "leetcode";
+        int expected = 73;
+        Assertions.assertEquals(expected, solution1165.calculateTime(keyboard, word));
+    }
+}

leetcode-12/src/test/java/Solution1176Tests.java

@@ -0,0 +1,36 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1176Tests {
+    private final Solution1176 solution1176 = new Solution1176();
+
+    @Test
+    public void example1() {
+        int[] calories = {1, 2, 3, 4, 5};
+        int k = 1;
+        int lower = 3;
+        int upper = 3;
+        int expected = 0;
+        Assertions.assertEquals(expected, solution1176.dietPlanPerformance(calories, k, lower, upper));
+    }
+
+    @Test
+    public void example2() {
+        int[] calories = {3, 2};
+        int k = 2;
+        int lower = 0;
+        int upper = 1;
+        int expected = 1;
+        Assertions.assertEquals(expected, solution1176.dietPlanPerformance(calories, k, lower, upper));
+    }
+
+    @Test
+    public void example3() {
+        int[] calories = {6, 5, 0, 0};
+        int k = 2;
+        int lower = 1;
+        int upper = 5;
+        int expected = 0;
+        Assertions.assertEquals(expected, solution1176.dietPlanPerformance(calories, k, lower, upper));
+    }
+}

leetcode-12/src/test/java/Solution1180Tests.java

@@ -0,0 +1,20 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1180Tests {
+    private final Solution1180 solution1180 = new Solution1180();
+
+    @Test
+    public void example1() {
+        String s = "aaaba";
+        int expected = 8;
+        Assertions.assertEquals(expected, solution1180.countLetters(s));
+    }
+
+    @Test
+    public void example2() {
+        String s = "aaaaaaaaaa";
+        int expected = 55;
+        Assertions.assertEquals(expected, solution1180.countLetters(s));
+    }
+}

leetcode-13/src/main/java/Solution1228.java

@@ -0,0 +1,32 @@
+public class Solution1228 {
+    public int missingNumber(int[] arr) {
+        int n = arr.length;
+        int d1 = arr[1] - arr[0];
+        int d2 = arr[n - 1] - arr[n - 2];
+        if (d1 == 0 || d2 == 0) {
+            return arr[0];
+        }
+        // 公差
+        int d = (d1 / d2 == 2) ? d2 : d1;
+        for (int i = 1; i < n; i++) {
+            if (arr[i] - arr[i - 1] != d) {
+                return arr[i] - d;
+            }
+        }
+        return -1;
+    }
+}
+/*
+$1228. 等差数列中缺失的数字
+https://leetcode.cn/problems/missing-number-in-arithmetic-progression/
+
+在某个数组 arr 中，值符合等差数列的数值规律：在 0 <= i < arr.length - 1 的前提下，arr[i+1] - arr[i] 的值都相等。
+我们会从该数组中删除一个 既不是第一个 也 不是最后一个的值，得到一个新的数组  arr。
+给你这个缺值的数组 arr，返回 被删除的那个数 。
+提示：
+3 <= arr.length <= 1000
+0 <= arr[i] <= 10^5
+给定的数组 保证 是一个有效的数组。
+
+求出公差后枚举
+ */

leetcode-13/src/main/java/Solution1243.java

@@ -0,0 +1,37 @@
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Solution1243 {
+    public List<Integer> transformArray(int[] arr) {
+        int n = arr.length;
+        int[] arrCopy = arr.clone();
+        for (int i = 1; i <= n - 2; i++) {
+            if (arr[i] > arrCopy[i - 1] && arr[i] > arrCopy[i + 1]) {
+                arr[i]--;
+            } else if (arr[i] < arrCopy[i - 1] && arr[i] < arrCopy[i + 1]) {
+                arr[i]++;
+            }
+        }
+        if (Arrays.equals(arr, arrCopy)) {
+            return Arrays.stream(arr).boxed().collect(Collectors.toList());
+        }
+        return transformArray(arr);
+    }
+}
+/*
+$1243. 数组变换
+https://leetcode.cn/problems/array-transformation/
+
+首先，给你一个初始数组 arr。然后，每天你都要根据前一天的数组生成一个新的数组。
+第 i 天所生成的数组，是由你对第 i-1 天的数组进行如下操作所得的：
+1. 假如一个元素小于它的左右邻居，那么该元素自增 1。
+2. 假如一个元素大于它的左右邻居，那么该元素自减 1。
+3. 首、尾元素 永不 改变。
+过些时日，你会发现数组将会不再发生变化，请返回最终所得到的数组。
+提示：
+1 <= arr.length <= 100
+1 <= arr[i] <= 100
+
+暴力模拟
+ */

leetcode-13/src/main/java/Solution1271.java

@@ -0,0 +1,34 @@
+public class Solution1271 {
+    public String toHexspeak(String num) {
+        num = Long.toString(Long.parseLong(num), 16).toUpperCase()
+                .replace("0", "O")
+                .replace("1", "I");
+        for (char ch : num.toCharArray()) {
+            if (!"ABCDEFIO".contains(String.valueOf(ch))) {
+                return "ERROR";
+            }
+        }
+        return num;
+    }
+}
+/*
+$1271. 十六进制魔术数字
+https://leetcode.cn/problems/hexspeak/
+
+你有一个十进制数字，请按照此规则将它变成「十六进制魔术数字」：首先将它变成字母大写的十六进制字符串，然后将所有的数字 0 变成字母 O ，将数字 1  变成字母 I 。
+如果一个数字在转换后只包含 {"A", "B", "C", "D", "E", "F", "I", "O"} ，那么我们就认为这个转换是有效的。
+给你一个字符串 num ，它表示一个十进制数 N，如果它的十六进制魔术数字转换是有效的，请返回转换后的结果，否则返回 "ERROR" 。
+示例 1：
+输入：num = "257"
+输出："IOI"
+解释：257 的十六进制表示是 101 。
+示例 2：
+输入：num = "3"
+输出："ERROR"
+提示：
+1 <= N <= 10^12
+给定字符串不会有前导 0 。
+结果中的所有字母都应该是大写字母。
+
+模拟
+ */

leetcode-13/src/test/java/Solution1228Tests.java

@@ -0,0 +1,48 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1228Tests {
+    private final Solution1228 solution1228 = new Solution1228();
+
+    @Test
+    public void example1() {
+        int[] arr = {5, 7, 11, 13};
+        int expected = 9;
+        Assertions.assertEquals(expected, solution1228.missingNumber(arr));
+    }
+
+    @Test
+    public void example2() {
+        int[] arr = {15, 13, 12};
+        int expected = 14;
+        Assertions.assertEquals(expected, solution1228.missingNumber(arr));
+    }
+
+    // 补充用例
+    @Test
+    public void example3() {
+        // https://leetcode.cn/submissions/detail/396157152/
+        // 公差为 0
+        int[] arr = {0, 0, 0, 0, 0};
+        int expected = 0;
+        Assertions.assertEquals(expected, solution1228.missingNumber(arr));
+    }
+
+    @Test
+    public void example4() {
+        // https://leetcode.cn/submissions/detail/396157210/
+        // 公差为负数，不能取最小值
+        int[] arr = {80387, 68178, 55969, 31551};
+        int expected = 43760;
+        Assertions.assertEquals(expected, solution1228.missingNumber(arr));
+    }
+
+    @Test
+    public void example5() {
+        // https://leetcode.cn/submissions/detail/396157210/
+        // 公差为 0
+        int[] arr = {1, 1, 1};
+        int expected = 1;
+        Assertions.assertEquals(expected, solution1228.missingNumber(arr));
+    }
+}