Merge remote-tracking branch 'origin/master'
This commit is contained in:
commit
2ab1e255b1
88
src/main/java/leetcode/editor/cn/AddStrings.java
Normal file
88
src/main/java/leetcode/editor/cn/AddStrings.java
Normal file
@ -0,0 +1,88 @@
|
||||
//<p>给定两个字符串形式的非负整数 <code>num1</code> 和<code>num2</code> ，计算它们的和并同样以字符串形式返回。</p>
|
||||
//
|
||||
//<p>你不能使用任何內建的用于处理大整数的库（比如 <code>BigInteger</code>）， 也不能直接将输入的字符串转换为整数形式。</p>
|
||||
//
|
||||
//<p> </p>
|
||||
//
|
||||
//<p><strong>示例 1：</strong></p>
|
||||
//
|
||||
//<pre>
|
||||
//<strong>输入：</strong>num1 = "11", num2 = "123"
|
||||
//<strong>输出：</strong>"134"
|
||||
//</pre>
|
||||
//
|
||||
//<p><strong>示例 2：</strong></p>
|
||||
//
|
||||
//<pre>
|
||||
//<strong>输入：</strong>num1 = "456", num2 = "77"
|
||||
//<strong>输出：</strong>"533"
|
||||
//</pre>
|
||||
//
|
||||
//<p><strong>示例 3：</strong></p>
|
||||
//
|
||||
//<pre>
|
||||
//<strong>输入：</strong>num1 = "0", num2 = "0"
|
||||
//<strong>输出：</strong>"0"
|
||||
//</pre>
|
||||
//
|
||||
//<p> </p>
|
||||
//
|
||||
//<p> </p>
|
||||
//
|
||||
//<p><strong>提示：</strong></p>
|
||||
//
|
||||
//<ul>
|
||||
// <li><code>1 <= num1.length, num2.length <= 10<sup>4</sup></code></li>
|
||||
// <li><code>num1</code> 和<code>num2</code> 都只包含数字 <code>0-9</code></li>
|
||||
// <li><code>num1</code> 和<code>num2</code> 都不包含任何前导零</li>
|
||||
//</ul>
|
||||
//<div><div>Related Topics</div><div><li>数学</li><li>字符串</li><li>模拟</li></div></div><br><div><li>👍 541</li><li>👎 0</li></div>
|
||||
package leetcode.editor.cn;
|
||||
|
||||
/**
|
||||
* Classname ${NAME}
|
||||
* Description 415:字符串相加
|
||||
* Date ${DATE} ${TIME}
|
||||
* author ${USER}
|
||||
*/
|
||||
public class AddStrings {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new AddStrings().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public String addStrings(String num1, String num2) {
|
||||
StringBuilder str = new StringBuilder();
|
||||
StringBuilder sb1 = new StringBuilder(num1);
|
||||
StringBuilder sb2 = new StringBuilder(num2);
|
||||
sb1.reverse();
|
||||
sb2.reverse();
|
||||
int index = 0;
|
||||
int sum = 0;
|
||||
while (index < sb1.length() || index < sb2.length()) {
|
||||
if (index < sb1.length()) {
|
||||
sum += (sb1.charAt(index) - '0');
|
||||
}
|
||||
if (index < sb2.length()) {
|
||||
sum += (sb2.charAt(index) - '0');
|
||||
}
|
||||
if (sum >= 10) {
|
||||
str.insert(0, (sum % 10));
|
||||
sum /= 10;
|
||||
} else {
|
||||
str.insert(0, sum);
|
||||
sum = 0;
|
||||
}
|
||||
index++;
|
||||
}
|
||||
if (sum > 0) {
|
||||
str.insert(0, sum);
|
||||
}
|
||||
return str.toString();
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,71 @@
|
||||
//给你一个整数数组 salary ，数组里每个数都是 唯一 的，其中 salary[i] 是第 i 个员工的工资。
|
||||
//
|
||||
// 请你返回去掉最低工资和最高工资以后，剩下员工工资的平均值。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
// 输入：salary = [4000,3000,1000,2000]
|
||||
//输出：2500.00000
|
||||
//解释：最低工资和最高工资分别是 1000 和 4000 。
|
||||
//去掉最低工资和最高工资以后的平均工资是 (2000+3000)/2= 2500
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
// 输入：salary = [1000,2000,3000]
|
||||
//输出：2000.00000
|
||||
//解释：最低工资和最高工资分别是 1000 和 3000 。
|
||||
//去掉最低工资和最高工资以后的平均工资是 (2000)/1= 2000
|
||||
//
|
||||
//
|
||||
// 示例 3：
|
||||
//
|
||||
// 输入：salary = [6000,5000,4000,3000,2000,1000]
|
||||
//输出：3500.00000
|
||||
//
|
||||
//
|
||||
// 示例 4：
|
||||
//
|
||||
// 输入：salary = [8000,9000,2000,3000,6000,1000]
|
||||
//输出：4750.00000
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 3 <= salary.length <= 100
|
||||
// 10^3 <= salary[i] <= 10^6
|
||||
// salary[i] 是唯一的。
|
||||
// 与真实值误差在 10^-5 以内的结果都将视为正确答案。
|
||||
//
|
||||
// Related Topics 数组 排序 👍 33 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
//1491:去掉最低工资和最高工资后的工资平均值
|
||||
public class AverageSalaryExcludingTheMinimumAndMaximumSalary {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new AverageSalaryExcludingTheMinimumAndMaximumSalary().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public double average(int[] salary) {
|
||||
Arrays.sort(salary);
|
||||
double avg = 0d;
|
||||
for (int i = 1; i < salary.length - 1; i++) {
|
||||
avg += salary[i];
|
||||
}
|
||||
return avg / (salary.length - 2);
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
118
src/main/java/leetcode/editor/cn/BinaryWatch.java
Normal file
118
src/main/java/leetcode/editor/cn/BinaryWatch.java
Normal file
@ -0,0 +1,118 @@
|
||||
//二进制手表顶部有 4 个 LED 代表 小时（0-11），底部的 6 个 LED 代表 分钟（0-59）。每个 LED 代表一个 0 或 1，最低位在右侧。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 例如，下面的二进制手表读取 "3:25" 。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// （图源：WikiMedia - Binary clock samui moon.jpg ，许可协议：Attribution-ShareAlike 3.0
|
||||
//Unported (CC BY-SA 3.0) ）
|
||||
//
|
||||
// 给你一个整数 turnedOn ，表示当前亮着的 LED 的数量，返回二进制手表可以表示的所有可能时间。你可以 按任意顺序 返回答案。
|
||||
//
|
||||
// 小时不会以零开头：
|
||||
//
|
||||
//
|
||||
// 例如，"01:00" 是无效的时间，正确的写法应该是 "1:00" 。
|
||||
//
|
||||
//
|
||||
// 分钟必须由两位数组成，可能会以零开头：
|
||||
//
|
||||
//
|
||||
// 例如，"10:2" 是无效的时间，正确的写法应该是 "10:02" 。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：turnedOn = 1
|
||||
//输出：["0:01","0:02","0:04","0:08","0:16","0:32","1:00","2:00","4:00","8:00"]
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：turnedOn = 9
|
||||
//输出：[]
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 0 <= turnedOn <= 10
|
||||
//
|
||||
// Related Topics 位运算 回溯 👍 356 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
//401:二进制手表
|
||||
public class BinaryWatch {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new BinaryWatch().new Solution();
|
||||
// TO TEST
|
||||
System.out.println(solution.readBinaryWatch(2));
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public List<String> readBinaryWatch(int turnedOn) {
|
||||
if (turnedOn > 8) {
|
||||
return new ArrayList<>();
|
||||
}
|
||||
Map<Integer, Set<Integer>> map1 = getNums(4, turnedOn);
|
||||
Map<Integer, Set<Integer>> map2 = getNums(6, turnedOn);
|
||||
List<String> list = new ArrayList<>();
|
||||
for (int key : map1.keySet()) {
|
||||
if (turnedOn - key >= 6) {
|
||||
continue;
|
||||
}
|
||||
for (int hour : map1.get(key)) {
|
||||
for (int mini : map2.get(turnedOn - key)) {
|
||||
list.add(hour + ":" + String.format("%02d", mini));
|
||||
}
|
||||
}
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
private Map<Integer, Set<Integer>> getNums(int line, int turnedOn) {
|
||||
Map<Integer, Set<Integer>> map = new HashMap<>(line);
|
||||
int[] arrs = new int[line];
|
||||
arrs[0] = 1;
|
||||
for (int i = 1; i < line; i++) {
|
||||
arrs[i] = 2 * arrs[i - 1];
|
||||
}
|
||||
for (int i = 0; i <= Math.min(line, turnedOn); i++) {
|
||||
if (i == 0) {
|
||||
map.put(i, new HashSet<>(Collections.singletonList(0)));
|
||||
} else {
|
||||
Set<Integer> set = map.get(i - 1);
|
||||
Set<Integer> cur = new HashSet<>();
|
||||
for (int num : set) {
|
||||
for (int j = 0; j < line; j++) {
|
||||
if ((num & arrs[j]) == 0) {
|
||||
if (line == 4 && (num | arrs[j]) < 12) {
|
||||
cur.add(num | arrs[j]);
|
||||
} else if (line == 6 && (num | arrs[j]) < 60) {
|
||||
cur.add(num | arrs[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
map.put(i, cur);
|
||||
}
|
||||
}
|
||||
return map;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,63 @@
|
||||
//<p>给你一个数字数组 <code>arr</code> 。</p>
|
||||
//
|
||||
//<p>如果一个数列中，任意相邻两项的差总等于同一个常数，那么这个数列就称为 <strong>等差数列</strong> 。</p>
|
||||
//
|
||||
//<p>如果可以重新排列数组形成等差数列，请返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
|
||||
//
|
||||
//<p> </p>
|
||||
//
|
||||
//<p><strong>示例 1：</strong></p>
|
||||
//
|
||||
//<pre><strong>输入：</strong>arr = [3,5,1]
|
||||
//<strong>输出：</strong>true
|
||||
//<strong>解释：</strong>对数组重新排序得到 [1,3,5] 或者 [5,3,1] ，任意相邻两项的差分别为 2 或 -2 ，可以形成等差数列。
|
||||
//</pre>
|
||||
//
|
||||
//<p><strong>示例 2：</strong></p>
|
||||
//
|
||||
//<pre><strong>输入：</strong>arr = [1,2,4]
|
||||
//<strong>输出：</strong>false
|
||||
//<strong>解释：</strong>无法通过重新排序得到等差数列。
|
||||
//</pre>
|
||||
//
|
||||
//<p> </p>
|
||||
//
|
||||
//<p><strong>提示：</strong></p>
|
||||
//
|
||||
//<ul>
|
||||
// <li><code>2 <= arr.length <= 1000</code></li>
|
||||
// <li><code>-10^6 <= arr[i] <= 10^6</code></li>
|
||||
//</ul>
|
||||
//<div><div>Related Topics</div><div><li>数组</li><li>排序</li></div></div><br><div><li>👍 23</li><li>👎 0</li></div>
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
/**
|
||||
* Classname ${NAME}
|
||||
* Description 1502:判断能否形成等差数列
|
||||
* Date ${DATE} ${TIME}
|
||||
* author ${USER}
|
||||
*/
|
||||
public class CanMakeArithmeticProgressionFromSequence {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new CanMakeArithmeticProgressionFromSequence().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public boolean canMakeArithmeticProgression(int[] arr) {
|
||||
Arrays.sort(arr);
|
||||
int sub = arr[1] - arr[0];
|
||||
for (int i = 2; i < arr.length; i++) {
|
||||
if (arr[i] - arr[i - 1] != sub) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,92 @@
|
||||
//<p>给你长度相等的两个字符串 <code>s1</code> 和 <code>s2</code> 。一次<strong> 字符串交换 </strong>操作的步骤如下：选出某个字符串中的两个下标（不必不同），并交换这两个下标所对应的字符。</p>
|
||||
//
|
||||
//<p>如果对 <strong>其中一个字符串</strong> 执行 <strong>最多一次字符串交换</strong> 就可以使两个字符串相等，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
|
||||
//
|
||||
//<p> </p>
|
||||
//
|
||||
//<p><strong>示例 1：</strong></p>
|
||||
//
|
||||
//<pre><strong>输入：</strong>s1 = "bank", s2 = "kanb"
|
||||
//<strong>输出：</strong>true
|
||||
//<strong>解释：</strong>例如，交换 s2 中的第一个和最后一个字符可以得到 "bank"
|
||||
//</pre>
|
||||
//
|
||||
//<p><strong>示例 2：</strong></p>
|
||||
//
|
||||
//<pre><strong>输入：</strong>s1 = "attack", s2 = "defend"
|
||||
//<strong>输出：</strong>false
|
||||
//<strong>解释：</strong>一次字符串交换无法使两个字符串相等
|
||||
//</pre>
|
||||
//
|
||||
//<p><strong>示例 3：</strong></p>
|
||||
//
|
||||
//<pre><strong>输入：</strong>s1 = "kelb", s2 = "kelb"
|
||||
//<strong>输出：</strong>true
|
||||
//<strong>解释：</strong>两个字符串已经相等，所以不需要进行字符串交换
|
||||
//</pre>
|
||||
//
|
||||
//<p><strong>示例 4：</strong></p>
|
||||
//
|
||||
//<pre><strong>输入：</strong>s1 = "abcd", s2 = "dcba"
|
||||
//<strong>输出：</strong>false
|
||||
//</pre>
|
||||
//
|
||||
//<p> </p>
|
||||
//
|
||||
//<p><strong>提示：</strong></p>
|
||||
//
|
||||
//<ul>
|
||||
// <li><code>1 <= s1.length, s2.length <= 100</code></li>
|
||||
// <li><code>s1.length == s2.length</code></li>
|
||||
// <li><code>s1</code> 和 <code>s2</code> 仅由小写英文字母组成</li>
|
||||
//</ul>
|
||||
//<div><div>Related Topics</div><div><li>哈希表</li><li>字符串</li><li>计数</li></div></div><br><div><li>👍 29</li><li>👎 0</li></div>
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Classname ${NAME}
|
||||
* Description 1790:仅执行一次字符串交换能否使两个字符串相等
|
||||
* Date ${DATE} ${TIME}
|
||||
* author ${USER}
|
||||
*/
|
||||
public class CheckIfOneStringSwapCanMakeStringsEqual {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new CheckIfOneStringSwapCanMakeStringsEqual().new Solution();
|
||||
// TO TEST
|
||||
System.out.println(solution.areAlmostEqual("bank", "kanb"));
|
||||
System.out.println(solution.areAlmostEqual("attack", "defend"));
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public boolean areAlmostEqual(String s1, String s2) {
|
||||
if (s1.length() != s2.length()) {
|
||||
return false;
|
||||
}
|
||||
if (s1.equals(s2)) {
|
||||
return true;
|
||||
}
|
||||
List<Integer> list = new ArrayList<>();
|
||||
for (int i = 0; i < s1.length(); i++) {
|
||||
if (s1.charAt(i) != s2.charAt(i)) {
|
||||
if (list.size() == 1) {
|
||||
int index = list.get(0);
|
||||
s1 = s1.substring(0, index)
|
||||
+ s1.charAt(i)
|
||||
+ s1.substring(index + 1, i)
|
||||
+ s1.charAt(index)
|
||||
+ s1.substring(i + 1);
|
||||
return s1.equals(s2);
|
||||
}
|
||||
list.add(i);
|
||||
}
|
||||
}
|
||||
return list.size() == 0;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,80 @@
|
||||
//给定一个不为空的二叉搜索树和一个目标值 target，请在该二叉搜索树中找到最接近目标值 target 的数值。
|
||||
//
|
||||
// 注意：
|
||||
//
|
||||
//
|
||||
// 给定的目标值 target 是一个浮点数
|
||||
// 题目保证在该二叉搜索树中只会存在一个最接近目标值的数
|
||||
//
|
||||
//
|
||||
// 示例：
|
||||
//
|
||||
// 输入: root = [4,2,5,1,3]，目标值 target = 3.714286
|
||||
//
|
||||
// 4
|
||||
// / \
|
||||
// 2 5
|
||||
// / \
|
||||
//1 3
|
||||
//
|
||||
//输出: 4
|
||||
//
|
||||
// Related Topics 树 深度优先搜索 二叉搜索树 二分查找 二叉树 👍 112 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import com.code.leet.entiy.TreeNode;
|
||||
|
||||
//270:最接近的二叉搜索树值
|
||||
public class ClosestBinarySearchTreeValue {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new ClosestBinarySearchTreeValue().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* public class TreeNode {
|
||||
* int val;
|
||||
* TreeNode left;
|
||||
* TreeNode right;
|
||||
* TreeNode() {}
|
||||
* TreeNode(int val) { this.val = val; }
|
||||
* TreeNode(int val, TreeNode left, TreeNode right) {
|
||||
* this.val = val;
|
||||
* this.left = left;
|
||||
* this.right = right;
|
||||
* }
|
||||
* }
|
||||
*/
|
||||
class Solution {
|
||||
public int closestValue(TreeNode root, double target) {
|
||||
double left = target;
|
||||
double right = target;
|
||||
float diff = 1e-6f;
|
||||
while (root != null) {
|
||||
if (Math.abs(root.val - target) < diff) {
|
||||
return root.val;
|
||||
}
|
||||
if (root.val > target) {
|
||||
right = root.val;
|
||||
root = root.left;
|
||||
} else {
|
||||
left = root.val;
|
||||
root = root.right;
|
||||
}
|
||||
}
|
||||
|
||||
if (Math.abs(left - target) < diff) {
|
||||
return (int) right;
|
||||
} else if (Math.abs(right - target) < diff) {
|
||||
return (int) left;
|
||||
} else {
|
||||
return target - left > right - target ? (int) right : (int) left;
|
||||
}
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,63 @@
|
||||
//给你一个整数 n ，统计并返回各位数字都不同的数字 x 的个数，其中 0 <= x < 10ⁿ 。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：n = 2
|
||||
//输出：91
|
||||
//解释：答案应为除去 11、22、33、44、55、66、77、88、99 外，在 0 ≤ x < 100 范围内的所有数字。
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：n = 0
|
||||
//输出：1
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 0 <= n <= 8
|
||||
//
|
||||
// Related Topics 数学 动态规划 回溯 👍 217 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//357:统计各位数字都不同的数字个数
|
||||
public class CountNumbersWithUniqueDigits {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new CountNumbersWithUniqueDigits().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int countNumbersWithUniqueDigits(int n) {
|
||||
if (n == 0) {
|
||||
return 1;
|
||||
}
|
||||
if (n == 1) {
|
||||
return 10;
|
||||
}
|
||||
int sub = 9;
|
||||
int count = 10;
|
||||
int mul = 9;
|
||||
for (int i = 2; i <= n; i++) {
|
||||
count += mul * sub;
|
||||
mul *= sub;
|
||||
sub--;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,43 @@
|
||||
//给你两个非负整数 low 和 high 。请你返回 low 和 high 之间（包括二者）奇数的数目。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
// 输入：low = 3, high = 7
|
||||
//输出：3
|
||||
//解释：3 到 7 之间奇数数字为 [3,5,7] 。
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
// 输入：low = 8, high = 10
|
||||
//输出：1
|
||||
//解释：8 到 10 之间奇数数字为 [9] 。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 0 <= low <= high <= 10^9
|
||||
//
|
||||
// Related Topics 数学 👍 48 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//1523:在区间范围内统计奇数数目
|
||||
public class CountOddNumbersInAnIntervalRange {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new CountOddNumbersInAnIntervalRange().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int countOdds(int low, int high) {
|
||||
return (high + 1) / 2 - (low) / 2;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
111
src/main/java/leetcode/editor/cn/CountPrimes.java
Normal file
111
src/main/java/leetcode/editor/cn/CountPrimes.java
Normal file
@ -0,0 +1,111 @@
|
||||
//给定整数 n ，返回 所有小于非负整数 n 的质数的数量 。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：n = 10
|
||||
//输出：4
|
||||
//解释：小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：n = 0
|
||||
//输出：0
|
||||
//
|
||||
//
|
||||
// 示例 3：
|
||||
//
|
||||
//
|
||||
//输入：n = 1
|
||||
//输出：0
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 0 <= n <= 5 * 10⁶
|
||||
//
|
||||
// Related Topics 数组 数学 枚举 数论 👍 869 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
//204:计数质数
|
||||
public class CountPrimes {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new CountPrimes().new Solution();
|
||||
// TO TEST
|
||||
solution.countPrimes(499979);
|
||||
}
|
||||
|
||||
//class Solution {
|
||||
// public int countPrimes(int n) {
|
||||
// if (n <= 2) {
|
||||
// return 0;
|
||||
// }
|
||||
// int count = 1;
|
||||
// for (int i = 3; i < n; i++) {
|
||||
// if (isPrime(i)) {
|
||||
// count++;
|
||||
// }
|
||||
// }
|
||||
// return count;
|
||||
// }
|
||||
|
||||
// /**
|
||||
// * 判断是否是质数
|
||||
// *
|
||||
// * @param num 数字
|
||||
// * @return true：质数、false：不是质数
|
||||
// */
|
||||
// private boolean isPrime(int num) {
|
||||
// if (num < 2) {
|
||||
// return false;
|
||||
// }
|
||||
// if (num == 2) {
|
||||
// return true;
|
||||
// }
|
||||
// for (int i = 2; i * i <= num; i++) {
|
||||
// if (num % i == 0) {
|
||||
// return false;
|
||||
// }
|
||||
// }
|
||||
// return true;
|
||||
// }
|
||||
//}
|
||||
|
||||
class Solution {
|
||||
public int countPrimes(int n) {
|
||||
if (n <= 2) {
|
||||
return 0;
|
||||
}
|
||||
boolean[] nums = new boolean[n + 1];
|
||||
Arrays.fill(nums, true);
|
||||
nums[0] = false;
|
||||
nums[1] = false;
|
||||
int count = 0;
|
||||
int max = (int) Math.sqrt(n);
|
||||
for (int i = 2; i < n; i++) {
|
||||
if (nums[i]) {
|
||||
count++;
|
||||
if (i > max) {
|
||||
continue;
|
||||
}
|
||||
for (int j = i; j * i < n; j++) {
|
||||
nums[j * i] = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
74
src/main/java/leetcode/editor/cn/CountingBits.java
Normal file
74
src/main/java/leetcode/editor/cn/CountingBits.java
Normal file
@ -0,0 +1,74 @@
|
||||
//给你一个整数 n ，对于 0 <= i <= n 中的每个 i ，计算其二进制表示中 1 的个数 ，返回一个长度为 n + 1 的数组 ans 作为答案。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：n = 2
|
||||
//输出：[0,1,1]
|
||||
//解释：
|
||||
//0 --> 0
|
||||
//1 --> 1
|
||||
//2 --> 10
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：n = 5
|
||||
//输出：[0,1,1,2,1,2]
|
||||
//解释：
|
||||
//0 --> 0
|
||||
//1 --> 1
|
||||
//2 --> 10
|
||||
//3 --> 11
|
||||
//4 --> 100
|
||||
//5 --> 101
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 0 <= n <= 10⁵
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 进阶：
|
||||
//
|
||||
//
|
||||
// 很容易就能实现时间复杂度为 O(n log n) 的解决方案，你可以在线性时间复杂度 O(n) 内用一趟扫描解决此问题吗？
|
||||
// 你能不使用任何内置函数解决此问题吗？（如，C++ 中的 __builtin_popcount ）
|
||||
//
|
||||
//
|
||||
//
|
||||
// Related Topics 位运算 动态规划 👍 967 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//338:比特位计数
|
||||
public class CountingBits {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new CountingBits().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int[] countBits(int n) {
|
||||
int[] arrs = new int[n+1];
|
||||
for (int i = 0; i <= n; i++) {
|
||||
arrs[i] = Integer.bitCount(i);
|
||||
}
|
||||
return arrs;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,82 @@
|
||||
//给你两个整数 x 和 y ，表示你在一个笛卡尔坐标系下的 (x, y) 处。同时，在同一个坐标系下给你一个数组 points ，其中 points[i] =
|
||||
// [ai, bi] 表示在 (ai, bi) 处有一个点。当一个点与你所在的位置有相同的 x 坐标或者相同的 y 坐标时，我们称这个点是 有效的 。
|
||||
//
|
||||
// 请返回距离你当前位置 曼哈顿距离 最近的 有效 点的下标（下标从 0 开始）。如果有多个最近的有效点，请返回下标 最小 的一个。如果没有有效点，请返回 -
|
||||
//1 。
|
||||
//
|
||||
// 两个点 (x1, y1) 和 (x2, y2) 之间的 曼哈顿距离 为 abs(x1 - x2) + abs(y1 - y2) 。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：x = 3, y = 4, points = [[1,2],[3,1],[2,4],[2,3],[4,4]]
|
||||
//输出：2
|
||||
//解释：所有点中，[3,1]，[2,4] 和 [4,4] 是有效点。有效点中，[2,4] 和 [4,4] 距离你当前位置的曼哈顿距离最小，都为 1 。[2,4
|
||||
//] 的下标最小，所以返回 2 。
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：x = 3, y = 4, points = [[3,4]]
|
||||
//输出：0
|
||||
//提示：答案可以与你当前所在位置坐标相同。
|
||||
//
|
||||
// 示例 3：
|
||||
//
|
||||
//
|
||||
//输入：x = 3, y = 4, points = [[2,3]]
|
||||
//输出：-1
|
||||
//解释：没有 有效点。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 1 <= points.length <= 10⁴
|
||||
// points[i].length == 2
|
||||
// 1 <= x, y, ai, bi <= 10⁴
|
||||
//
|
||||
// Related Topics 数组 👍 26 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//1779:找到最近的有相同 X 或 Y 坐标的点
|
||||
public class FindNearestPointThatHasTheSameXOrYCoordinate {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new FindNearestPointThatHasTheSameXOrYCoordinate().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int nearestValidPoint(int x, int y, int[][] points) {
|
||||
int index = -1;
|
||||
int minDistance = Integer.MAX_VALUE;
|
||||
for (int i = 0; i < points.length; i++) {
|
||||
//边界1：坐标与x，y相同，直接返回下标
|
||||
if ((points[i][0] == x) && (points[i][1] == y)) {
|
||||
return i;
|
||||
}
|
||||
//边界2：坐标与x，y都不相同，直接进入下一循环，不参与distance计算
|
||||
if ((points[i][0] != x) && (points[i][1] != y)) {
|
||||
continue;
|
||||
}
|
||||
//若坐标中只有一个值与x or y匹配
|
||||
if ((points[i][0] == x) || (points[i][1] == y)) {
|
||||
int distance = Math.abs(points[i][0] - x) + Math.abs(points[i][1] - y);
|
||||
if (distance < minDistance) {
|
||||
minDistance = distance;
|
||||
index = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
return index;
|
||||
}
|
||||
}
|
||||
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
101
src/main/java/leetcode/editor/cn/Finding3DigitEvenNumbers.java
Normal file
101
src/main/java/leetcode/editor/cn/Finding3DigitEvenNumbers.java
Normal file
@ -0,0 +1,101 @@
|
||||
//给你一个整数数组 digits ，其中每个元素是一个数字（0 - 9）。数组中可能存在重复元素。
|
||||
//
|
||||
// 你需要找出 所有 满足下述条件且 互不相同 的整数：
|
||||
//
|
||||
//
|
||||
// 该整数由 digits 中的三个元素按 任意 顺序 依次连接 组成。
|
||||
// 该整数不含 前导零
|
||||
// 该整数是一个 偶数
|
||||
//
|
||||
//
|
||||
// 例如，给定的 digits 是 [1, 2, 3] ，整数 132 和 312 满足上面列出的全部条件。
|
||||
//
|
||||
// 将找出的所有互不相同的整数按 递增顺序 排列，并以数组形式返回。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：digits = [2,1,3,0]
|
||||
//输出：[102,120,130,132,210,230,302,310,312,320]
|
||||
//解释：
|
||||
//所有满足题目条件的整数都在输出数组中列出。
|
||||
//注意，答案数组中不含有 奇数 或带 前导零 的整数。
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：digits = [2,2,8,8,2]
|
||||
//输出：[222,228,282,288,822,828,882]
|
||||
//解释：
|
||||
//同样的数字（0 - 9）在构造整数时可以重复多次，重复次数最多与其在 digits 中出现的次数一样。
|
||||
//在这个例子中，数字 8 在构造 288、828 和 882 时都重复了两次。
|
||||
//
|
||||
//
|
||||
// 示例 3：
|
||||
//
|
||||
//
|
||||
//输入：digits = [3,7,5]
|
||||
//输出：[]
|
||||
//解释：
|
||||
//使用给定的 digits 无法构造偶数。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 3 <= digits.length <= 100
|
||||
// 0 <= digits[i] <= 9
|
||||
//
|
||||
// Related Topics 数组 哈希表 枚举 排序 👍 16 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
//2094:找出 3 位偶数
|
||||
public class Finding3DigitEvenNumbers {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new Finding3DigitEvenNumbers().new Solution();
|
||||
// TO TEST
|
||||
solution.findEvenNumbers(new int[]{2, 1, 3, 0});
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int[] findEvenNumbers(int[] digits) {
|
||||
Set<Integer> set = new HashSet<>();
|
||||
int len = digits.length;
|
||||
for (int i = 0; i < len; i++) {
|
||||
if (digits[i] == 0) {
|
||||
continue;
|
||||
}
|
||||
for (int j = 0; j < len; j++) {
|
||||
if (j == i) {
|
||||
continue;
|
||||
}
|
||||
for (int k = 0; k < len; k++) {
|
||||
if (k == i || k == j || digits[k] % 2 != 0) {
|
||||
continue;
|
||||
}
|
||||
int num = digits[i] * 100 + digits[j] * 10 + digits[k];
|
||||
set.add(num);
|
||||
}
|
||||
}
|
||||
}
|
||||
int size = set.size();
|
||||
int[] res = new int[size];
|
||||
int index = 0;
|
||||
for (int num : set) {
|
||||
res[index++] = num;
|
||||
}
|
||||
Arrays.sort(res);
|
||||
return res;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
61
src/main/java/leetcode/editor/cn/FlipGame.java
Normal file
61
src/main/java/leetcode/editor/cn/FlipGame.java
Normal file
@ -0,0 +1,61 @@
|
||||
//你和朋友玩一个叫做「翻转游戏」的游戏。游戏规则如下：
|
||||
//
|
||||
// 给你一个字符串 currentState ，其中只含 '+' 和 '-' 。你和朋友轮流将 连续 的两个 "++" 反转成 "--" 。当一方无法进行有效
|
||||
//的翻转时便意味着游戏结束，则另一方获胜。
|
||||
//
|
||||
// 计算并返回 一次有效操作 后，字符串 currentState 所有的可能状态，返回结果可以按 任意顺序 排列。如果不存在可能的有效操作，请返回一个空列表
|
||||
// [] 。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：currentState = "++++"
|
||||
//输出：["--++","+--+","++--"]
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：currentState = "+"
|
||||
//输出：[]
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 1 <= currentState.length <= 500
|
||||
// currentState[i] 不是 '+' 就是 '-'
|
||||
//
|
||||
// Related Topics 字符串 👍 33 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
//293:翻转游戏
|
||||
public class FlipGame {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new FlipGame().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public List<String> generatePossibleNextMoves(String currentState) {
|
||||
List<String> list = new ArrayList<>();
|
||||
for (int i = 1; i < currentState.length(); i++) {
|
||||
if(currentState.charAt(i-1)=='+'&¤tState.charAt(i)=='+'){
|
||||
list.add(currentState.substring(0,i-1)+"--"+currentState.substring(i+1));
|
||||
}
|
||||
}
|
||||
return list;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
67
src/main/java/leetcode/editor/cn/LexicographicalNumbers.java
Normal file
67
src/main/java/leetcode/editor/cn/LexicographicalNumbers.java
Normal file
@ -0,0 +1,67 @@
|
||||
//<p>给你一个整数 <code>n</code> ，按字典序返回范围 <code>[1, n]</code> 内所有整数。</p>
|
||||
//
|
||||
//<p>你必须设计一个时间复杂度为 <code>O(n)</code> 且使用 <code>O(1)</code> 额外空间的算法。</p>
|
||||
//
|
||||
//<p> </p>
|
||||
//
|
||||
//<p><strong>示例 1：</strong></p>
|
||||
//
|
||||
//<pre>
|
||||
//<strong>输入：</strong>n = 13
|
||||
//<strong>输出：</strong>[1,10,11,12,13,2,3,4,5,6,7,8,9]
|
||||
//</pre>
|
||||
//
|
||||
//<p><strong>示例 2：</strong></p>
|
||||
//
|
||||
//<pre>
|
||||
//<strong>输入：</strong>n = 2
|
||||
//<strong>输出：</strong>[1,2]
|
||||
//</pre>
|
||||
//
|
||||
//<p> </p>
|
||||
//
|
||||
//<p><strong>提示：</strong></p>
|
||||
//
|
||||
//<ul>
|
||||
// <li><code>1 <= n <= 5 * 10<sup>4</sup></code></li>
|
||||
//</ul>
|
||||
//<div><div>Related Topics</div><div><li>深度优先搜索</li><li>字典树</li></div></div><br><div><li>👍 277</li><li>👎 0</li></div>
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
// 386:字典序排数
|
||||
public class LexicographicalNumbers {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new LexicographicalNumbers().new Solution();
|
||||
// TO TEST
|
||||
solution.lexicalOrder(13);
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public List<Integer> lexicalOrder(int n) {
|
||||
dfs(n, 1);
|
||||
return list;
|
||||
}
|
||||
|
||||
List<Integer> list = new ArrayList<>();
|
||||
|
||||
private void dfs(int n, int num) {
|
||||
if (num > n) {
|
||||
return;
|
||||
}
|
||||
list.add(num);
|
||||
dfs(n, num * 10);
|
||||
if (num % 10 == 0 || num == 1) {
|
||||
int max = (num / 10 + 1) * 10;
|
||||
for (int i = num + 1; i < max; i++) {
|
||||
dfs(n, i);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
94
src/main/java/leetcode/editor/cn/LoggerRateLimiter.java
Normal file
94
src/main/java/leetcode/editor/cn/LoggerRateLimiter.java
Normal file
@ -0,0 +1,94 @@
|
||||
//请你设计一个日志系统，可以流式接收消息以及它的时间戳。每条 不重复 的消息最多只能每 10 秒打印一次。也就是说，如果在时间戳 t 打印某条消息，那么相同内
|
||||
//容的消息直到时间戳变为 t + 10 之前都不会被打印。
|
||||
//
|
||||
// 所有消息都按时间顺序发送。多条消息可能到达同一时间戳。
|
||||
//
|
||||
// 实现 Logger 类：
|
||||
//
|
||||
//
|
||||
// Logger() 初始化 logger 对象
|
||||
// bool shouldPrintMessage(int timestamp, string message) 如果这条消息 message 在给定的时间戳
|
||||
// timestamp 应该被打印出来，则返回 true ，否则请返回 false 。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例：
|
||||
//
|
||||
//
|
||||
//输入：
|
||||
//["Logger", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage",
|
||||
//"shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage"]
|
||||
//[[], [1, "foo"], [2, "bar"], [3, "foo"], [8, "bar"], [10, "foo"], [11, "foo"]]
|
||||
//
|
||||
//输出：
|
||||
//[null, true, true, false, false, false, true]
|
||||
//
|
||||
//解释：
|
||||
//Logger logger = new Logger();
|
||||
//logger.shouldPrintMessage(1, "foo"); // 返回 true ，下一次 "foo" 可以打印的时间戳是 1 + 10 =
|
||||
// 11
|
||||
//logger.shouldPrintMessage(2, "bar"); // 返回 true ，下一次 "bar" 可以打印的时间戳是 2 + 10 =
|
||||
// 12
|
||||
//logger.shouldPrintMessage(3, "foo"); // 3 < 11 ，返回 false
|
||||
//logger.shouldPrintMessage(8, "bar"); // 8 < 12 ，返回 false
|
||||
//logger.shouldPrintMessage(10, "foo"); // 10 < 11 ，返回 false
|
||||
//logger.shouldPrintMessage(11, "foo"); // 11 >= 11 ，返回 true ，下一次 "foo" 可以打印的时间戳
|
||||
//是 11 + 10 = 21
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 0 <= timestamp <= 10⁹
|
||||
// 每个 timestamp 都将按非递减顺序（时间顺序）传递
|
||||
// 1 <= message.length <= 30
|
||||
// 最多调用 10⁴ 次 shouldPrintMessage 方法
|
||||
//
|
||||
// Related Topics 设计 哈希表 👍 62 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
//359:日志速率限制器
|
||||
public class LoggerRateLimiter {
|
||||
public static void main(String[] args) {
|
||||
//Solution solution = new LoggerRateLimiter().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Logger {
|
||||
Map<String,Integer> map;
|
||||
|
||||
public Logger() {
|
||||
map = new HashMap<>();
|
||||
}
|
||||
|
||||
public boolean shouldPrintMessage(int timestamp, String message) {
|
||||
if(map.containsKey(message)){
|
||||
if(map.get(message)+10<=timestamp){
|
||||
map.put(message,timestamp);
|
||||
return true;
|
||||
}else{
|
||||
return false;
|
||||
}
|
||||
}else{
|
||||
map.put(message,timestamp);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Your Logger object will be instantiated and called as such:
|
||||
* Logger obj = new Logger();
|
||||
* boolean param_1 = obj.shouldPrintMessage(timestamp,message);
|
||||
*/
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
57
src/main/java/leetcode/editor/cn/MeetingRooms.java
Normal file
57
src/main/java/leetcode/editor/cn/MeetingRooms.java
Normal file
@ -0,0 +1,57 @@
|
||||
//给定一个会议时间安排的数组 intervals ，每个会议时间都会包括开始和结束的时间 intervals[i] = [starti, endi] ，请你判
|
||||
//断一个人是否能够参加这里面的全部会议。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：intervals = [[0,30],[5,10],[15,20]]
|
||||
//输出：false
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：intervals = [[7,10],[2,4]]
|
||||
//输出：true
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 0 <= intervals.length <= 10⁴
|
||||
// intervals[i].length == 2
|
||||
// 0 <= starti < endi <= 10⁶
|
||||
//
|
||||
// Related Topics 数组 排序 👍 117 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Comparator;
|
||||
|
||||
//252:会议室
|
||||
public class MeetingRooms {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new MeetingRooms().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public boolean canAttendMeetings(int[][] intervals) {
|
||||
Arrays.sort(intervals, Comparator.comparingInt(e -> e[0]));
|
||||
for (int i = 1; i < intervals.length; i++) {
|
||||
if(intervals[i][0]<intervals[i-1][1]){
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,71 @@
|
||||
//给你两个字符串 current 和 correct ，表示两个 24 小时制时间 。
|
||||
//
|
||||
// 24 小时制时间 按 "HH:MM" 进行格式化，其中 HH 在 00 和 23 之间，而 MM 在 00 和 59 之间。最早的 24 小时制时间为 0
|
||||
//0:00 ，最晚的是 23:59 。
|
||||
//
|
||||
// 在一步操作中，你可以将 current 这个时间增加 1、5、15 或 60 分钟。你可以执行这一操作 任意 次数。
|
||||
//
|
||||
// 返回将 current 转化为 correct 需要的 最少操作数 。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
// 输入：current = "02:30", correct = "04:35"
|
||||
//输出：3
|
||||
//解释：
|
||||
//可以按下述 3 步操作将 current 转换为 correct ：
|
||||
//- 为 current 加 60 分钟，current 变为 "03:30" 。
|
||||
//- 为 current 加 60 分钟，current 变为 "04:30" 。
|
||||
//- 为 current 加 5 分钟，current 变为 "04:35" 。
|
||||
//可以证明，无法用少于 3 步操作将 current 转化为 correct 。
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
// 输入：current = "11:00", correct = "11:01"
|
||||
//输出：1
|
||||
//解释：只需要为 current 加一分钟，所以最小操作数是 1 。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// current 和 correct 都符合 "HH:MM" 格式
|
||||
// current <= correct
|
||||
//
|
||||
// Related Topics 贪心 字符串 👍 7 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//2224:转化时间需要的最少操作数
|
||||
public class MinimumNumberOfOperationsToConvertTime {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new MinimumNumberOfOperationsToConvertTime().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int convertTime(String current, String correct) {
|
||||
String strs1[] = current.split(":");
|
||||
String strs2[] = correct.split(":");
|
||||
int sum = Integer.parseInt(strs2[0]) * 60
|
||||
+ Integer.parseInt(strs2[1])
|
||||
- Integer.parseInt(strs1[0]) * 60
|
||||
- Integer.parseInt(strs1[1]);
|
||||
int count = 0;
|
||||
int[] arrs = new int[]{60, 15, 5, 1};
|
||||
for (int arr : arrs) {
|
||||
if (sum >= arr) {
|
||||
count += sum / arr;
|
||||
sum %= arr;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,71 @@
|
||||
//我们要把给定的字符串 S 从左到右写到每一行上，每一行的最大宽度为100个单位，如果我们在写某个字母的时候会使这行超过了100 个单位，那么我们应该把这个字
|
||||
//母写到下一行。我们给定了一个数组 widths ，这个数组 widths[0] 代表 'a' 需要的单位， widths[1] 代表 'b' 需要的单位，...
|
||||
//， widths[25] 代表 'z' 需要的单位。
|
||||
//
|
||||
// 现在回答两个问题：至少多少行能放下S，以及最后一行使用的宽度是多少个单位？将你的答案作为长度为2的整数列表返回。
|
||||
//
|
||||
//
|
||||
//示例 1:
|
||||
//输入:
|
||||
//widths = [10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10
|
||||
//,10,10,10]
|
||||
//S = "abcdefghijklmnopqrstuvwxyz"
|
||||
//输出: [3, 60]
|
||||
//解释:
|
||||
//所有的字符拥有相同的占用单位10。所以书写所有的26个字母，
|
||||
//我们需要2个整行和占用60个单位的一行。
|
||||
//
|
||||
//
|
||||
//
|
||||
//示例 2:
|
||||
//输入:
|
||||
//widths = [4,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
|
||||
//10,10,10]
|
||||
//S = "bbbcccdddaaa"
|
||||
//输出: [2, 4]
|
||||
//解释:
|
||||
//除去字母'a'所有的字符都是相同的单位10，并且字符串 "bbbcccdddaa" 将会覆盖 9 * 10 + 2 * 4 = 98 个单位.
|
||||
//最后一个字母 'a' 将会被写到第二行，因为第一行只剩下2个单位了。
|
||||
//所以，这个答案是2行，第二行有4个单位宽度。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 注:
|
||||
//
|
||||
//
|
||||
// 字符串 S 的长度在 [1, 1000] 的范围。
|
||||
// S 只包含小写字母。
|
||||
// widths 是长度为 26的数组。
|
||||
// widths[i] 值的范围在 [2, 10]。
|
||||
//
|
||||
// Related Topics 数组 字符串 👍 69 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//806:写字符串需要的行数
|
||||
public class NumberOfLinesToWriteString {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new NumberOfLinesToWriteString().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int[] numberOfLines(int[] widths, String s) {
|
||||
int[] arrs = new int[]{1,0};
|
||||
int sum = 0;
|
||||
for(char ch:s.toCharArray()){
|
||||
sum+=widths[ch-'a'];
|
||||
if(sum>100){
|
||||
arrs[0]++;
|
||||
sum = widths[ch-'a'];
|
||||
}
|
||||
}
|
||||
arrs[1] = sum;
|
||||
return arrs;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
49
src/main/java/leetcode/editor/cn/PalindromePermutation.java
Normal file
49
src/main/java/leetcode/editor/cn/PalindromePermutation.java
Normal file
@ -0,0 +1,49 @@
|
||||
//给定一个字符串，判断该字符串中是否可以通过重新排列组合，形成一个回文字符串。
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
// 输入: "code"
|
||||
//输出: false
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
// 输入: "aab"
|
||||
//输出: true
|
||||
//
|
||||
// 示例 3：
|
||||
//
|
||||
// 输入: "carerac"
|
||||
//输出: true
|
||||
// Related Topics 位运算 哈希表 字符串 👍 59 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//266:回文排列
|
||||
public class PalindromePermutation {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new PalindromePermutation().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public boolean canPermutePalindrome(String s) {
|
||||
int[] arrs = new int[26];
|
||||
for (char ch : s.toCharArray()) {
|
||||
arrs[ch - 'a']++;
|
||||
}
|
||||
int count = 0;
|
||||
for (int i = 0; i < 26; i++) {
|
||||
if (arrs[i] % 2 == 1) {
|
||||
if (count == 1) {
|
||||
return false;
|
||||
}
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
80
src/main/java/leetcode/editor/cn/RangeSumQueryImmutable.java
Normal file
80
src/main/java/leetcode/editor/cn/RangeSumQueryImmutable.java
Normal file
@ -0,0 +1,80 @@
|
||||
//给定一个整数数组 nums，处理以下类型的多个查询:
|
||||
//
|
||||
//
|
||||
// 计算索引 left 和 right （包含 left 和 right）之间的 nums 元素的 和 ，其中 left <= right
|
||||
//
|
||||
//
|
||||
// 实现 NumArray 类：
|
||||
//
|
||||
//
|
||||
// NumArray(int[] nums) 使用数组 nums 初始化对象
|
||||
// int sumRange(int i, int j) 返回数组 nums 中索引 left 和 right 之间的元素的 总和 ，包含 left 和
|
||||
//right 两点（也就是 nums[left] + nums[left + 1] + ... + nums[right] )
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：
|
||||
//["NumArray", "sumRange", "sumRange", "sumRange"]
|
||||
//[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]
|
||||
//输出：
|
||||
//[null, 1, -1, -3]
|
||||
//
|
||||
//解释：
|
||||
//NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
|
||||
//numArray.sumRange(0, 2); // return 1 ((-2) + 0 + 3)
|
||||
//numArray.sumRange(2, 5); // return -1 (3 + (-5) + 2 + (-1))
|
||||
//numArray.sumRange(0, 5); // return -3 ((-2) + 0 + 3 + (-5) + 2 + (-1))
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 1 <= nums.length <= 10⁴
|
||||
// -10⁵ <= nums[i] <= 10⁵
|
||||
// 0 <= i <= j < nums.length
|
||||
// 最多调用 10⁴ 次 sumRange 方法
|
||||
//
|
||||
// Related Topics 设计 数组 前缀和 👍 443 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//303:区域和检索 - 数组不可变
|
||||
public class RangeSumQueryImmutable {
|
||||
public static void main(String[] args) {
|
||||
//Solution solution = new RangeSumQueryImmutable().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class NumArray {
|
||||
|
||||
int[] nums;
|
||||
int[] sums;
|
||||
|
||||
public NumArray(int[] nums) {
|
||||
this.nums = nums;
|
||||
sums = new int[nums.length + 1];
|
||||
for (int i = 0; i < nums.length; i++) {
|
||||
sums[i + 1] = sums[i] + nums[i];
|
||||
}
|
||||
}
|
||||
|
||||
public int sumRange(int left, int right) {
|
||||
return sums[right + 1] - sums[left];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Your NumArray object will be instantiated and called as such:
|
||||
* NumArray obj = new NumArray(nums);
|
||||
* int param_1 = obj.sumRange(left,right);
|
||||
*/
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,66 @@
|
||||
//<p>给定一个非空的字符串<meta charset="UTF-8" /> <code>s</code> ，检查是否可以通过由它的一个子串重复多次构成。</p>
|
||||
//
|
||||
//<p> </p>
|
||||
//
|
||||
//<p><strong>示例 1:</strong></p>
|
||||
//
|
||||
//<pre>
|
||||
//<strong>输入:</strong> s = "abab"
|
||||
//<strong>输出:</strong> true
|
||||
//<strong>解释:</strong> 可由子串 "ab" 重复两次构成。
|
||||
//</pre>
|
||||
//
|
||||
//<p><strong>示例 2:</strong></p>
|
||||
//
|
||||
//<pre>
|
||||
//<strong>输入:</strong> s = "aba"
|
||||
//<strong>输出:</strong> false
|
||||
//</pre>
|
||||
//
|
||||
//<p><strong>示例 3:</strong></p>
|
||||
//
|
||||
//<pre>
|
||||
//<strong>输入:</strong> s = "abcabcabcabc"
|
||||
//<strong>输出:</strong> true
|
||||
//<strong>解释:</strong> 可由子串 "abc" 重复四次构成。 (或子串 "abcabc" 重复两次构成。)
|
||||
//</pre>
|
||||
//
|
||||
//<p> </p>
|
||||
//
|
||||
//<p><b>提示：</b></p>
|
||||
//
|
||||
//<p><meta charset="UTF-8" /></p>
|
||||
//
|
||||
//<ul>
|
||||
// <li><code>1 <= s.length <= 10<sup>4</sup></code></li>
|
||||
// <li><code>s</code> 由小写英文字母组成</li>
|
||||
//</ul>
|
||||
//<div><div>Related Topics</div><div><li>字符串</li><li>字符串匹配</li></div></div><br><div><li>👍 676</li><li>👎 0</li></div>
|
||||
package leetcode.editor.cn;
|
||||
|
||||
// 459:重复的子字符串
|
||||
public class RepeatedSubstringPattern {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new RepeatedSubstringPattern().new Solution();
|
||||
// TO TEST
|
||||
solution.repeatedSubstringPattern("aaaa");
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public boolean repeatedSubstringPattern(String s) {
|
||||
int lens = s.length();
|
||||
for (int i = 1; i < lens; i++) {
|
||||
if (lens % i == 0) {
|
||||
if (s.substring(0, i).equals(s.substring(lens - i))
|
||||
&& s.substring(i).equals(s.substring(0, lens - i))) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
71
src/main/java/leetcode/editor/cn/RichestCustomerWealth.java
Normal file
71
src/main/java/leetcode/editor/cn/RichestCustomerWealth.java
Normal file
@ -0,0 +1,71 @@
|
||||
//给你一个 m x n 的整数网格 accounts ，其中 accounts[i][j] 是第 i 位客户在第 j 家银行托管的资产数量。返回最富有客户所拥
|
||||
//有的 资产总量 。
|
||||
//
|
||||
// 客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
// 输入：accounts = [[1,2,3],[3,2,1]]
|
||||
//输出：6
|
||||
//解释：
|
||||
//第 1 位客户的资产总量 = 1 + 2 + 3 = 6
|
||||
//第 2 位客户的资产总量 = 3 + 2 + 1 = 6
|
||||
//两位客户都是最富有的，资产总量都是 6 ，所以返回 6 。
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
// 输入：accounts = [[1,5],[7,3],[3,5]]
|
||||
//输出：10
|
||||
//解释：
|
||||
//第 1 位客户的资产总量 = 6
|
||||
//第 2 位客户的资产总量 = 10
|
||||
//第 3 位客户的资产总量 = 8
|
||||
//第 2 位客户是最富有的，资产总量是 10
|
||||
//
|
||||
// 示例 3：
|
||||
//
|
||||
// 输入：accounts = [[2,8,7],[7,1,3],[1,9,5]]
|
||||
//输出：17
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// m == accounts.length
|
||||
// n == accounts[i].length
|
||||
// 1 <= m, n <= 50
|
||||
// 1 <= accounts[i][j] <= 100
|
||||
//
|
||||
// Related Topics 数组 矩阵 👍 53 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//1672:最富有客户的资产总量
|
||||
public class RichestCustomerWealth {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new RichestCustomerWealth().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int maximumWealth(int[][] accounts) {
|
||||
int max = 0;
|
||||
for (int[] account : accounts) {
|
||||
int sum = 0;
|
||||
for (int i : account) {
|
||||
sum += i;
|
||||
}
|
||||
max = Math.max(max, sum);
|
||||
}
|
||||
return max;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
90
src/main/java/leetcode/editor/cn/RingsAndRods.java
Normal file
90
src/main/java/leetcode/editor/cn/RingsAndRods.java
Normal file
@ -0,0 +1,90 @@
|
||||
//总计有 n 个环，环的颜色可以是红、绿、蓝中的一种。这些环分布穿在 10 根编号为 0 到 9 的杆上。
|
||||
//
|
||||
// 给你一个长度为 2n 的字符串 rings ，表示这 n 个环在杆上的分布。rings 中每两个字符形成一个 颜色位置对 ，用于描述每个环：
|
||||
//
|
||||
//
|
||||
// 第 i 对中的 第一个 字符表示第 i 个环的 颜色（'R'、'G'、'B'）。
|
||||
// 第 i 对中的 第二个 字符表示第 i 个环的 位置，也就是位于哪根杆上（'0' 到 '9'）。
|
||||
//
|
||||
//
|
||||
// 例如，"R3G2B1" 表示：共有 n == 3 个环，红色的环在编号为 3 的杆上，绿色的环在编号为 2 的杆上，蓝色的环在编号为 1 的杆上。
|
||||
//
|
||||
// 找出所有集齐 全部三种颜色 环的杆，并返回这种杆的数量。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
// 输入：rings = "B0B6G0R6R0R6G9"
|
||||
//输出：1
|
||||
//解释：
|
||||
//- 编号 0 的杆上有 3 个环，集齐全部颜色：红、绿、蓝。
|
||||
//- 编号 6 的杆上有 3 个环，但只有红、蓝两种颜色。
|
||||
//- 编号 9 的杆上只有 1 个绿色环。
|
||||
//因此，集齐全部三种颜色环的杆的数目为 1 。
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
// 输入：rings = "B0R0G0R9R0B0G0"
|
||||
//输出：1
|
||||
//解释：
|
||||
//- 编号 0 的杆上有 6 个环，集齐全部颜色：红、绿、蓝。
|
||||
//- 编号 9 的杆上只有 1 个红色环。
|
||||
//因此，集齐全部三种颜色环的杆的数目为 1 。
|
||||
//
|
||||
//
|
||||
// 示例 3：
|
||||
//
|
||||
// 输入：rings = "G4"
|
||||
//输出：0
|
||||
//解释：
|
||||
//只给了一个环，因此，不存在集齐全部三种颜色环的杆。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// rings.length == 2 * n
|
||||
// 1 <= n <= 100
|
||||
// 如 i 是 偶数 ，则 rings[i] 的值可以取 'R'、'G' 或 'B'（下标从 0 开始计数）
|
||||
// 如 i 是 奇数 ，则 rings[i] 的值可以取 '0' 到 '9' 中的一个数字（下标从 0 开始计数）
|
||||
//
|
||||
// Related Topics 哈希表 字符串 👍 13 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//2103:环和杆
|
||||
public class RingsAndRods {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new RingsAndRods().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int countPoints(String rings) {
|
||||
int[][] arrs = new int[10][3];
|
||||
for (int i = 0; i < rings.length(); i += 2) {
|
||||
if (rings.charAt(i) == 'R') {
|
||||
arrs[rings.charAt(i + 1) - '0'][0]++;
|
||||
} else if (rings.charAt(i) == 'G') {
|
||||
arrs[rings.charAt(i + 1) - '0'][1]++;
|
||||
} else {
|
||||
arrs[rings.charAt(i + 1) - '0'][2]++;
|
||||
}
|
||||
}
|
||||
int count = 0;
|
||||
for (int[] arr : arrs) {
|
||||
if (arr[0] * arr[1] * arr[2] > 0) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
65
src/main/java/leetcode/editor/cn/ShortestWordDistance.java
Normal file
65
src/main/java/leetcode/editor/cn/ShortestWordDistance.java
Normal file
@ -0,0 +1,65 @@
|
||||
//给定一个字符串数组 wordDict 和两个已经存在于该数组中的不同的字符串 word1 和 word2 。返回列表中这两个单词之间的最短距离。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1:
|
||||
//
|
||||
//
|
||||
//输入: wordsDict = ["practice", "makes", "perfect", "coding", "makes"], word1 =
|
||||
//"coding", word2 = "practice"
|
||||
//输出: 3
|
||||
//
|
||||
//
|
||||
// 示例 2:
|
||||
//
|
||||
//
|
||||
//输入: wordsDict = ["practice", "makes", "perfect", "coding", "makes"], word1 =
|
||||
//"makes", word2 = "coding"
|
||||
//输出: 1
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示:
|
||||
//
|
||||
//
|
||||
// 1 <= wordsDict.length <= 3 * 10⁴
|
||||
// 1 <= wordsDict[i].length <= 10
|
||||
// wordsDict[i] 由小写英文字母组成
|
||||
// word1 和 word2 在 wordsDict 中
|
||||
// word1 != word2
|
||||
//
|
||||
// Related Topics 数组 字符串 👍 90 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//243:最短单词距离
|
||||
public class ShortestWordDistance {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new ShortestWordDistance().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int shortestDistance(String[] wordsDict, String word1, String word2) {
|
||||
int[] arrs = new int[]{-1, -1};
|
||||
int length = wordsDict.length;
|
||||
for (int i = 0; i < wordsDict.length; i++) {
|
||||
if (wordsDict[i].equals(word1)) {
|
||||
arrs[0] = i;
|
||||
if(arrs[1]>-1){
|
||||
length = Math.min(length,arrs[0]-arrs[1]);
|
||||
}
|
||||
}else if (wordsDict[i].equals(word2)) {
|
||||
arrs[1] = i;
|
||||
if(arrs[0]>-1){
|
||||
length = Math.min(length,arrs[1]-arrs[0]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return length;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,78 @@
|
||||
//<p>已知函数 <code>signFunc(x)</code> 将会根据 <code>x</code> 的正负返回特定值：</p>
|
||||
//
|
||||
//<ul>
|
||||
// <li>如果 <code>x</code> 是正数，返回 <code>1</code> 。</li>
|
||||
// <li>如果 <code>x</code> 是负数，返回 <code>-1</code> 。</li>
|
||||
// <li>如果 <code>x</code> 是等于 <code>0</code> ，返回 <code>0</code> 。</li>
|
||||
//</ul>
|
||||
//
|
||||
//<p>给你一个整数数组 <code>nums</code> 。令 <code>product</code> 为数组 <code>nums</code> 中所有元素值的乘积。</p>
|
||||
//
|
||||
//<p>返回 <code>signFunc(product)</code> 。</p>
|
||||
//
|
||||
//<p> </p>
|
||||
//
|
||||
//<p><strong>示例 1：</strong></p>
|
||||
//
|
||||
//<pre>
|
||||
//<strong>输入：</strong>nums = [-1,-2,-3,-4,3,2,1]
|
||||
//<strong>输出：</strong>1
|
||||
//<strong>解释：</strong>数组中所有值的乘积是 144 ，且 signFunc(144) = 1
|
||||
//</pre>
|
||||
//
|
||||
//<p><strong>示例 2：</strong></p>
|
||||
//
|
||||
//<pre>
|
||||
//<strong>输入：</strong>nums = [1,5,0,2,-3]
|
||||
//<strong>输出：</strong>0
|
||||
//<strong>解释：</strong>数组中所有值的乘积是 0 ，且 signFunc(0) = 0
|
||||
//</pre>
|
||||
//
|
||||
//<p><strong>示例 3：</strong></p>
|
||||
//
|
||||
//<pre>
|
||||
//<strong>输入：</strong>nums = [-1,1,-1,1,-1]
|
||||
//<strong>输出：</strong>-1
|
||||
//<strong>解释：</strong>数组中所有值的乘积是 -1 ，且 signFunc(-1) = -1
|
||||
//</pre>
|
||||
//
|
||||
//<p> </p>
|
||||
//
|
||||
//<p><strong>提示：</strong></p>
|
||||
//
|
||||
//<ul>
|
||||
// <li><code>1 <= nums.length <= 1000</code></li>
|
||||
// <li><code>-100 <= nums[i] <= 100</code></li>
|
||||
//</ul>
|
||||
//<div><div>Related Topics</div><div><li>数组</li><li>数学</li></div></div><br><div><li>👍 20</li><li>👎 0</li></div>
|
||||
package leetcode.editor.cn;
|
||||
|
||||
/**
|
||||
* Classname ${NAME}
|
||||
* Description 1822:数组元素积的符号
|
||||
* Date ${DATE} ${TIME}
|
||||
* author ${USER}
|
||||
*/
|
||||
public class SignOfTheProductOfAnArray {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new SignOfTheProductOfAnArray().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int arraySign(int[] nums) {
|
||||
int count = 0;
|
||||
for (int i = 0; i < nums.length; i++) {
|
||||
if (nums[i] < 0) {
|
||||
count++;
|
||||
} else if (nums[i] == 0) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return count % 2 == 0 ? 1 : -1;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,61 @@
|
||||
//给你一个整数 n，请你帮忙计算并返回该整数「各位数字之积」与「各位数字之和」的差。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
// 输入：n = 234
|
||||
//输出：15
|
||||
//解释：
|
||||
//各位数之积 = 2 * 3 * 4 = 24
|
||||
//各位数之和 = 2 + 3 + 4 = 9
|
||||
//结果 = 24 - 9 = 15
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
// 输入：n = 4421
|
||||
//输出：21
|
||||
//解释：
|
||||
//各位数之积 = 4 * 4 * 2 * 1 = 32
|
||||
//各位数之和 = 4 + 4 + 2 + 1 = 11
|
||||
//结果 = 32 - 11 = 21
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 1 <= n <= 10^5
|
||||
//
|
||||
// Related Topics 数学 👍 81 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//1281:整数的各位积和之差
|
||||
public class SubtractTheProductAndSumOfDigitsOfAnInteger {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new SubtractTheProductAndSumOfDigitsOfAnInteger().new Solution();
|
||||
// TO TEST
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int subtractProductAndSum(int n) {
|
||||
int sum = 0;
|
||||
int mul = 1;
|
||||
while (n >= 10) {
|
||||
int tmp = n % 10;
|
||||
sum += tmp;
|
||||
mul *= tmp;
|
||||
n /= 10;
|
||||
}
|
||||
sum += n;
|
||||
mul *= n;
|
||||
return mul - sum;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
66
src/main/java/leetcode/editor/cn/ValidPerfectSquare.java
Normal file
66
src/main/java/leetcode/editor/cn/ValidPerfectSquare.java
Normal file
@ -0,0 +1,66 @@
|
||||
//给定一个 正整数 num ，编写一个函数，如果 num 是一个完全平方数，则返回 true ，否则返回 false 。
|
||||
//
|
||||
// 进阶：不要 使用任何内置的库函数，如 sqrt 。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：num = 16
|
||||
//输出：true
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：num = 14
|
||||
//输出：false
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 1 <= num <= 2^31 - 1
|
||||
//
|
||||
// Related Topics 数学 二分查找 👍 371 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//367:有效的完全平方数
|
||||
public class ValidPerfectSquare {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new ValidPerfectSquare().new Solution();
|
||||
// TO TEST
|
||||
System.out.println(solution.isPerfectSquare(16));
|
||||
System.out.println(solution.isPerfectSquare(808201));
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public boolean isPerfectSquare(int num) {
|
||||
if (num * num == num) {
|
||||
return true;
|
||||
}
|
||||
int left = 0;
|
||||
int right = num;
|
||||
while (left < right) {
|
||||
int mid = (right - left) / 2 + left;
|
||||
long mul = (long) mid * mid;
|
||||
if (mul == num) {
|
||||
return true;
|
||||
}
|
||||
if (mul < num) {
|
||||
left = mid + 1;
|
||||
} else {
|
||||
right = mid;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
96
src/main/java/leetcode/editor/cn/ValidWordAbbreviation.java
Normal file
96
src/main/java/leetcode/editor/cn/ValidWordAbbreviation.java
Normal file
@ -0,0 +1,96 @@
|
||||
//<p>字符串可以用 <strong>缩写</strong> 进行表示，<strong>缩写</strong> 的方法是将任意数量的 <strong>不相邻</strong> 的子字符串替换为相应子串的长度。例如，字符串 <code>"substitution"</code> 可以缩写为（不止这几种方法）：</p>
|
||||
//
|
||||
//<ul>
|
||||
// <li><code>"s10n"</code> (<code>"s <em><strong>ubstitutio</strong></em> n"</code>)</li>
|
||||
// <li><code>"sub4u4"</code> (<code>"sub <em><strong>stit</strong></em> u <em><strong>tion</strong></em>"</code>)</li>
|
||||
// <li><code>"12"</code> (<code>"<em><strong>substitution</strong></em>"</code>)</li>
|
||||
// <li><code>"su3i1u2on"</code> (<code>"su <em><strong>bst</strong></em> i <em><strong>t</strong></em> u <em><strong>ti</strong></em> on"</code>)</li>
|
||||
// <li><code>"substitution"</code> (没有替换子字符串)</li>
|
||||
//</ul>
|
||||
//
|
||||
//<p>下列是不合法的缩写：</p>
|
||||
//
|
||||
//<ul>
|
||||
// <li><code>"s55n"</code> (<code>"s <u>ubsti</u> <u>tutio</u> n"</code>，两处缩写相邻)</li>
|
||||
// <li><code>"s010n"</code> (缩写存在前导零)</li>
|
||||
// <li><code>"s0ubstitution"</code> (缩写是一个空字符串)</li>
|
||||
//</ul>
|
||||
//
|
||||
//<p>给你一个字符串单词 <code>word</code> 和一个缩写 <code>abbr</code> ，判断这个缩写是否可以是给定单词的缩写。</p>
|
||||
//
|
||||
//<p><strong>子字符串</strong>是字符串中连续的<strong>非空</strong>字符序列。</p>
|
||||
//
|
||||
//<p> </p>
|
||||
//
|
||||
//<p><strong>示例 1：</strong></p>
|
||||
//
|
||||
//<pre>
|
||||
//<strong>输入：</strong>word = "internationalization", abbr = "i12iz4n"
|
||||
//<strong>输出：</strong>true
|
||||
//<strong>解释：</strong>单词 "internationalization" 可以缩写为 "i12iz4n" ("i <em><strong>nternational</strong></em> iz <em><strong>atio</strong></em> n") 。
|
||||
//</pre>
|
||||
//
|
||||
//<p><strong>示例 2：</strong></p>
|
||||
//
|
||||
//<pre>
|
||||
//<strong>输入：</strong>word = "apple", abbr = "a2e"
|
||||
//<strong>输出：</strong>false
|
||||
//<strong>解释：</strong>单词 "apple" 无法缩写为 "a2e" 。
|
||||
//</pre>
|
||||
//
|
||||
//<p> </p>
|
||||
//
|
||||
//<p><strong>提示：</strong></p>
|
||||
//
|
||||
//<ul>
|
||||
// <li><code>1 <= word.length <= 20</code></li>
|
||||
// <li><code>word</code> 仅由小写英文字母组成</li>
|
||||
// <li><code>1 <= abbr.length <= 10</code></li>
|
||||
// <li><code>abbr</code> 由小写英文字母和数字组成</li>
|
||||
// <li><code>abbr</code> 中的所有数字均符合 32-bit 整数范围</li>
|
||||
//</ul>
|
||||
//<div><div>Related Topics</div><div><li>双指针</li><li>字符串</li></div></div><br><div><li>👍 39</li><li>👎 0</li></div>
|
||||
package leetcode.editor.cn;
|
||||
|
||||
/**
|
||||
* Classname ${NAME}
|
||||
* Description 408:有效单词缩写
|
||||
* Date ${DATE} ${TIME}
|
||||
* author ${USER}
|
||||
*/
|
||||
public class ValidWordAbbreviation {
|
||||
public static void main(String[] args) {
|
||||
Solution solution = new ValidWordAbbreviation().new Solution();
|
||||
// TO TEST
|
||||
//solution.validWordAbbreviation("internationalization","i12iz4n");
|
||||
solution.validWordAbbreviation("internationalization", "i5a11o1");
|
||||
}
|
||||
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public boolean validWordAbbreviation(String word, String abbr) {
|
||||
int index = 0;
|
||||
for (int i = 0; i < abbr.length(); i++) {
|
||||
if (Character.isDigit(abbr.charAt(i))) {
|
||||
int num = abbr.charAt(i) - '0';
|
||||
if (num == 0) {
|
||||
return false;
|
||||
}
|
||||
i++;
|
||||
while (i < abbr.length() && Character.isDigit(abbr.charAt(i))) {
|
||||
num = num * 10 + (abbr.charAt(i) - '0');
|
||||
i++;
|
||||
}
|
||||
index += num - 1;
|
||||
i--;
|
||||
} else if (index >= word.length() || abbr.charAt(i) != word.charAt(index)) {
|
||||
return false;
|
||||
}
|
||||
index++;
|
||||
}
|
||||
return index == word.length();
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
39
src/main/java/leetcode/editor/cn/doc/content/AddStrings.md
Normal file
39
src/main/java/leetcode/editor/cn/doc/content/AddStrings.md
Normal file
@ -0,0 +1,39 @@
|
||||
<p>给定两个字符串形式的非负整数 <code>num1</code> 和<code>num2</code> ，计算它们的和并同样以字符串形式返回。</p>
|
||||
|
||||
<p>你不能使用任何內建的用于处理大整数的库（比如 <code>BigInteger</code>）， 也不能直接将输入的字符串转换为整数形式。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>num1 = "11", num2 = "123"
|
||||
<strong>输出：</strong>"134"
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>num1 = "456", num2 = "77"
|
||||
<strong>输出：</strong>"533"
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>num1 = "0", num2 = "0"
|
||||
<strong>输出：</strong>"0"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= num1.length, num2.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>num1</code> 和<code>num2</code> 都只包含数字 <code>0-9</code></li>
|
||||
<li><code>num1</code> 和<code>num2</code> 都不包含任何前导零</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数学</li><li>字符串</li><li>模拟</li></div></div><br><div><li>👍 541</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,45 @@
|
||||
<p>给你一个整数数组 <code>salary</code> ，数组里每个数都是 <strong>唯一</strong> 的，其中 <code>salary[i]</code> 是第 <code>i</code> 个员工的工资。</p>
|
||||
|
||||
<p>请你返回去掉最低工资和最高工资以后，剩下员工工资的平均值。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>salary = [4000,3000,1000,2000]
|
||||
<strong>输出：</strong>2500.00000
|
||||
<strong>解释：</strong>最低工资和最高工资分别是 1000 和 4000 。
|
||||
去掉最低工资和最高工资以后的平均工资是 (2000+3000)/2= 2500
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>salary = [1000,2000,3000]
|
||||
<strong>输出：</strong>2000.00000
|
||||
<strong>解释：</strong>最低工资和最高工资分别是 1000 和 3000 。
|
||||
去掉最低工资和最高工资以后的平均工资是 (2000)/1= 2000
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>salary = [6000,5000,4000,3000,2000,1000]
|
||||
<strong>输出：</strong>3500.00000
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>salary = [8000,9000,2000,3000,6000,1000]
|
||||
<strong>输出：</strong>4750.00000
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= salary.length <= 100</code></li>
|
||||
<li><code>10^3 <= salary[i] <= 10^6</code></li>
|
||||
<li><code>salary[i]</code> 是唯一的。</li>
|
||||
<li>与真实值误差在 <code>10^-5</code> 以内的结果都将视为正确答案。</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>排序</li></div></div><br><div><li>👍 33</li><li>👎 0</li></div>
|
||||
48
src/main/java/leetcode/editor/cn/doc/content/BinaryWatch.md
Normal file
48
src/main/java/leetcode/editor/cn/doc/content/BinaryWatch.md
Normal file
@ -0,0 +1,48 @@
|
||||
<p>二进制手表顶部有 4 个 LED 代表<strong> 小时（0-11）</strong>，底部的 6 个 LED 代表<strong> 分钟（0-59）</strong>。每个 LED 代表一个 0 或 1，最低位在右侧。</p>
|
||||
|
||||
<ul>
|
||||
<li>例如，下面的二进制手表读取 <code>"3:25"</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p><img src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2021/03/29/binary_clock_samui_moon.jpg" style="height: 300px; width" /></p>
|
||||
|
||||
<p><small><em>（图源：<a href="https://commons.m.wikimedia.org/wiki/File:Binary_clock_samui_moon.jpg">WikiMedia - Binary clock samui moon.jpg</a> ，许可协议：<a href="https://creativecommons.org/licenses/by-sa/3.0/deed.en">Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)</a> ）</em></small></p>
|
||||
|
||||
<p>给你一个整数 <code>turnedOn</code> ，表示当前亮着的 LED 的数量，返回二进制手表可以表示的所有可能时间。你可以 <strong>按任意顺序</strong> 返回答案。</p>
|
||||
|
||||
<p>小时不会以零开头：</p>
|
||||
|
||||
<ul>
|
||||
<li>例如，<code>"01:00"</code> 是无效的时间，正确的写法应该是 <code>"1:00"</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>分钟必须由两位数组成，可能会以零开头：</p>
|
||||
|
||||
<ul>
|
||||
<li>例如，<code>"10:2"</code> 是无效的时间，正确的写法应该是 <code>"10:02"</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>turnedOn = 1
|
||||
<strong>输出：</strong>["0:01","0:02","0:04","0:08","0:16","0:32","1:00","2:00","4:00","8:00"]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>turnedOn = 9
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= turnedOn <= 10</code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>位运算</li><li>回溯</li></div></div><br><div><li>👍 356</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,31 @@
|
||||
<p>给你一个数字数组 <code>arr</code> 。</p>
|
||||
|
||||
<p>如果一个数列中，任意相邻两项的差总等于同一个常数，那么这个数列就称为 <strong>等差数列</strong> 。</p>
|
||||
|
||||
<p>如果可以重新排列数组形成等差数列，请返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>arr = [3,5,1]
|
||||
<strong>输出：</strong>true
|
||||
<strong>解释：</strong>对数组重新排序得到 [1,3,5] 或者 [5,3,1] ，任意相邻两项的差分别为 2 或 -2 ，可以形成等差数列。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>arr = [1,2,4]
|
||||
<strong>输出：</strong>false
|
||||
<strong>解释：</strong>无法通过重新排序得到等差数列。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= arr.length <= 1000</code></li>
|
||||
<li><code>-10^6 <= arr[i] <= 10^6</code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>排序</li></div></div><br><div><li>👍 23</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,43 @@
|
||||
<p>给你长度相等的两个字符串 <code>s1</code> 和 <code>s2</code> 。一次<strong> 字符串交换 </strong>操作的步骤如下：选出某个字符串中的两个下标（不必不同），并交换这两个下标所对应的字符。</p>
|
||||
|
||||
<p>如果对 <strong>其中一个字符串</strong> 执行 <strong>最多一次字符串交换</strong> 就可以使两个字符串相等，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s1 = "bank", s2 = "kanb"
|
||||
<strong>输出：</strong>true
|
||||
<strong>解释：</strong>例如，交换 s2 中的第一个和最后一个字符可以得到 "bank"
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s1 = "attack", s2 = "defend"
|
||||
<strong>输出：</strong>false
|
||||
<strong>解释：</strong>一次字符串交换无法使两个字符串相等
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s1 = "kelb", s2 = "kelb"
|
||||
<strong>输出：</strong>true
|
||||
<strong>解释：</strong>两个字符串已经相等，所以不需要进行字符串交换
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s1 = "abcd", s2 = "dcba"
|
||||
<strong>输出：</strong>false
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s1.length, s2.length <= 100</code></li>
|
||||
<li><code>s1.length == s2.length</code></li>
|
||||
<li><code>s1</code> 和 <code>s2</code> 仅由小写英文字母组成</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>哈希表</li><li>字符串</li><li>计数</li></div></div><br><div><li>👍 29</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,22 @@
|
||||
<p>给定一个不为空的二叉搜索树和一个目标值 target，请在该二叉搜索树中找到最接近目标值 target 的数值。</p>
|
||||
|
||||
<p><strong>注意：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>给定的目标值 target 是一个浮点数</li>
|
||||
<li>题目保证在该二叉搜索树中只会存在一个最接近目标值的数</li>
|
||||
</ul>
|
||||
|
||||
<p><strong>示例：</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> root = [4,2,5,1,3]，目标值 target = 3.714286
|
||||
|
||||
4
|
||||
/ \
|
||||
2 5
|
||||
/ \
|
||||
1 3
|
||||
|
||||
<strong>输出:</strong> 4
|
||||
</pre>
|
||||
<div><div>Related Topics</div><div><li>树</li><li>深度优先搜索</li><li>二叉搜索树</li><li>二分查找</li><li>二叉树</li></div></div><br><div><li>👍 112</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,30 @@
|
||||
给你一个整数 <code>n</code> ，统计并返回各位数字都不同的数字 <code>x</code> 的个数，其中 <code>0 <= x < 10<sup>n</sup></code><sup> </sup>。
|
||||
<div class="original__bRMd">
|
||||
<div>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 2
|
||||
<strong>输出：</strong>91
|
||||
<strong>解释：</strong>答案应为除去 <code>11、22、33、44、55、66、77、88、99 </code>外，在 0 ≤ x < 100 范围内的所有数字。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 0
|
||||
<strong>输出：</strong>1
|
||||
</pre>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= n <= 8</code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数学</li><li>动态规划</li><li>回溯</li></div></div><br><div><li>👍 217</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,24 @@
|
||||
<p>给你两个非负整数 <code>low</code> 和 <code>high</code> 。请你返回<em> </em><code>low</code><em> </em>和<em> </em><code>high</code><em> </em>之间（包括二者）奇数的数目。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>low = 3, high = 7
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>3 到 7 之间奇数数字为 [3,5,7] 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>low = 8, high = 10
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>8 到 10 之间奇数数字为 [9] 。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= low <= high <= 10^9</code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数学</li></div></div><br><div><li>👍 48</li><li>👎 0</li></div>
|
||||
34
src/main/java/leetcode/editor/cn/doc/content/CountPrimes.md
Normal file
34
src/main/java/leetcode/editor/cn/doc/content/CountPrimes.md
Normal file
@ -0,0 +1,34 @@
|
||||
<p>给定整数 <code>n</code> ，返回 <em>所有小于非负整数 <code>n</code> 的质数的数量</em> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 10
|
||||
<strong>输出：</strong>4
|
||||
<strong>解释：</strong>小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 0
|
||||
<strong>输出：</strong>0
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 1
|
||||
<strong>输出</strong>：0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= n <= 5 * 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>数学</li><li>枚举</li><li>数论</li></div></div><br><div><li>👍 869</li><li>👎 0</li></div>
|
||||
50
src/main/java/leetcode/editor/cn/doc/content/CountingBits.md
Normal file
50
src/main/java/leetcode/editor/cn/doc/content/CountingBits.md
Normal file
@ -0,0 +1,50 @@
|
||||
<p>给你一个整数 <code>n</code> ，对于 <code>0 <= i <= n</code> 中的每个 <code>i</code> ，计算其二进制表示中 <strong><code>1</code> 的个数</strong> ，返回一个长度为 <code>n + 1</code> 的数组 <code>ans</code> 作为答案。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<div class="original__bRMd">
|
||||
<div>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 2
|
||||
<strong>输出：</strong>[0,1,1]
|
||||
<strong>解释：</strong>
|
||||
0 --> 0
|
||||
1 --> 1
|
||||
2 --> 10
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 5
|
||||
<strong>输出：</strong>[0,1,1,2,1,2]
|
||||
<strong>解释：</strong>
|
||||
0 --> 0
|
||||
1 --> 1
|
||||
2 --> 10
|
||||
3 --> 11
|
||||
4 --> 100
|
||||
5 --> 101
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= n <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>很容易就能实现时间复杂度为 <code>O(n log n)</code> 的解决方案，你可以在线性时间复杂度 <code>O(n)</code> 内用一趟扫描解决此问题吗？</li>
|
||||
<li>你能不使用任何内置函数解决此问题吗？（如，C++ 中的 <code>__builtin_popcount</code> ）</li>
|
||||
</ul>
|
||||
</div>
|
||||
</div>
|
||||
<div><div>Related Topics</div><div><li>位运算</li><li>动态规划</li></div></div><br><div><li>👍 967</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,39 @@
|
||||
<p>给你两个整数 <code>x</code> 和 <code>y</code> ，表示你在一个笛卡尔坐标系下的 <code>(x, y)</code> 处。同时，在同一个坐标系下给你一个数组 <code>points</code> ，其中 <code>points[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> 表示在 <code>(a<sub>i</sub>, b<sub>i</sub>)</code> 处有一个点。当一个点与你所在的位置有相同的 <code>x</code> 坐标或者相同的 <code>y</code> 坐标时，我们称这个点是 <b>有效的</b> 。</p>
|
||||
|
||||
<p>请返回距离你当前位置 <strong>曼哈顿距离</strong> 最近的 <strong>有效</strong> 点的下标（下标从 <strong>0</strong> 开始）。如果有多个最近的有效点，请返回下标 <strong>最小</strong> 的一个。如果没有有效点，请返回 <code>-1</code> 。</p>
|
||||
|
||||
<p>两个点 <code>(x<sub>1</sub>, y<sub>1</sub>)</code> 和 <code>(x<sub>2</sub>, y<sub>2</sub>)</code> 之间的 <strong>曼哈顿距离</strong> 为 <code>abs(x<sub>1</sub> - x<sub>2</sub>) + abs(y<sub>1</sub> - y<sub>2</sub>)</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>x = 3, y = 4, points = [[1,2],[3,1],[2,4],[2,3],[4,4]]
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>所有点中，[3,1]，[2,4] 和 [4,4] 是有效点。有效点中，[2,4] 和 [4,4] 距离你当前位置的曼哈顿距离最小，都为 1 。[2,4] 的下标最小，所以返回 2 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>x = 3, y = 4, points = [[3,4]]
|
||||
<b>输出：</b>0
|
||||
<b>提示：</b>答案可以与你当前所在位置坐标相同。</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>x = 3, y = 4, points = [[2,3]]
|
||||
<b>输出：</b>-1
|
||||
<b>解释：</b>没有 有效点。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= points.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>points[i].length == 2</code></li>
|
||||
<li><code>1 <= x, y, a<sub>i</sub>, b<sub>i</sub> <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li></div></div><br><div><li>👍 26</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,53 @@
|
||||
<p>给你一个整数数组 <code>digits</code> ，其中每个元素是一个数字（<code>0 - 9</code>）。数组中可能存在重复元素。</p>
|
||||
|
||||
<p>你需要找出 <strong>所有</strong> 满足下述条件且 <strong>互不相同</strong> 的整数：</p>
|
||||
|
||||
<ul>
|
||||
<li>该整数由 <code>digits</code> 中的三个元素按 <strong>任意</strong> 顺序 <strong>依次连接</strong> 组成。</li>
|
||||
<li>该整数不含 <strong>前导零</strong></li>
|
||||
<li>该整数是一个 <strong>偶数</strong></li>
|
||||
</ul>
|
||||
|
||||
<p>例如，给定的 <code>digits</code> 是 <code>[1, 2, 3]</code> ，整数 <code>132</code> 和 <code>312</code> 满足上面列出的全部条件。</p>
|
||||
|
||||
<p>将找出的所有互不相同的整数按 <strong>递增顺序</strong> 排列，并以数组形式返回<em>。</em></p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>digits = [2,1,3,0]
|
||||
<strong>输出：</strong>[102,120,130,132,210,230,302,310,312,320]
|
||||
<strong>解释：</strong>
|
||||
所有满足题目条件的整数都在输出数组中列出。
|
||||
注意，答案数组中不含有 <strong>奇数</strong> 或带 <strong>前导零</strong> 的整数。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>digits = [2,2,8,8,2]
|
||||
<strong>输出：</strong>[222,228,282,288,822,828,882]
|
||||
<strong>解释：</strong>
|
||||
同样的数字（0 - 9）在构造整数时可以重复多次，重复次数最多与其在 <code>digits</code> 中出现的次数一样。
|
||||
在这个例子中，数字 8 在构造 288、828 和 882 时都重复了两次。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>digits = [3,7,5]
|
||||
<strong>输出：</strong>[]
|
||||
<strong>解释：</strong>
|
||||
使用给定的 digits 无法构造偶数。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= digits.length <= 100</code></li>
|
||||
<li><code>0 <= digits[i] <= 9</code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>哈希表</li><li>枚举</li><li>排序</li></div></div><br><div><li>👍 16</li><li>👎 0</li></div>
|
||||
31
src/main/java/leetcode/editor/cn/doc/content/FlipGame.md
Normal file
31
src/main/java/leetcode/editor/cn/doc/content/FlipGame.md
Normal file
@ -0,0 +1,31 @@
|
||||
<p>你和朋友玩一个叫做「翻转游戏」的游戏。游戏规则如下：</p>
|
||||
|
||||
<p>给你一个字符串 <code>currentState</code> ，其中只含 <code>'+'</code> 和 <code>'-'</code> 。你和朋友轮流将 <strong>连续 </strong>的两个 <code>"++"</code> 反转成 <code>"--"</code> 。当一方无法进行有效的翻转时便意味着游戏结束，则另一方获胜。</p>
|
||||
|
||||
<p>计算并返回 <strong>一次有效操作</strong> 后，字符串 <code>currentState</code> 所有的可能状态，返回结果可以按 <strong>任意顺序</strong> 排列。如果不存在可能的有效操作，请返回一个空列表 <code>[]</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>currentState = "++++"
|
||||
<strong>输出：</strong>["--++","+--+","++--"]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>currentState = "+"
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= currentState.length <= 500</code></li>
|
||||
<li><code>currentState[i]</code> 不是 <code>'+'</code> 就是 <code>'-'</code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>字符串</li></div></div><br><div><li>👍 33</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,28 @@
|
||||
<p>给你一个整数 <code>n</code> ，按字典序返回范围 <code>[1, n]</code> 内所有整数。</p>
|
||||
|
||||
<p>你必须设计一个时间复杂度为 <code>O(n)</code> 且使用 <code>O(1)</code> 额外空间的算法。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 13
|
||||
<strong>输出：</strong>[1,10,11,12,13,2,3,4,5,6,7,8,9]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 2
|
||||
<strong>输出：</strong>[1,2]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 5 * 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>深度优先搜索</li><li>字典树</li></div></div><br><div><li>👍 277</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,43 @@
|
||||
<p>请你设计一个日志系统，可以流式接收消息以及它的时间戳。每条 <strong>不重复</strong> 的消息最多只能每 10 秒打印一次。也就是说，如果在时间戳 <code>t</code> 打印某条消息，那么相同内容的消息直到时间戳变为 <code>t + 10</code> 之前都不会被打印。</p>
|
||||
|
||||
<p>所有消息都按时间顺序发送。多条消息可能到达同一时间戳。</p>
|
||||
|
||||
<p>实现 <code>Logger</code> 类：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>Logger()</code> 初始化 <code>logger</code> 对象</li>
|
||||
<li><code>bool shouldPrintMessage(int timestamp, string message)</code> 如果这条消息 <code>message</code> 在给定的时间戳 <code>timestamp</code> 应该被打印出来，则返回 <code>true</code> ，否则请返回 <code>false</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>
|
||||
["Logger", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage"]
|
||||
[[], [1, "foo"], [2, "bar"], [3, "foo"], [8, "bar"], [10, "foo"], [11, "foo"]]
|
||||
<strong>输出：</strong>
|
||||
[null, true, true, false, false, false, true]
|
||||
|
||||
<strong>解释：</strong>
|
||||
Logger logger = new Logger();
|
||||
logger.shouldPrintMessage(1, "foo"); // 返回 true ，下一次 "foo" 可以打印的时间戳是 1 + 10 = 11
|
||||
logger.shouldPrintMessage(2, "bar"); // 返回 true ，下一次 "bar" 可以打印的时间戳是 2 + 10 = 12
|
||||
logger.shouldPrintMessage(3, "foo"); // 3 < 11 ，返回 false
|
||||
logger.shouldPrintMessage(8, "bar"); // 8 < 12 ，返回 false
|
||||
logger.shouldPrintMessage(10, "foo"); // 10 < 11 ，返回 false
|
||||
logger.shouldPrintMessage(11, "foo"); // 11 >= 11 ，返回 true ，下一次 "foo" 可以打印的时间戳是 11 + 10 = 21
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= timestamp <= 10<sup>9</sup></code></li>
|
||||
<li>每个 <code>timestamp</code> 都将按非递减顺序（时间顺序）传递</li>
|
||||
<li><code>1 <= message.length <= 30</code></li>
|
||||
<li>最多调用 <code>10<sup>4</sup></code> 次 <code>shouldPrintMessage</code> 方法</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>设计</li><li>哈希表</li></div></div><br><div><li>👍 62</li><li>👎 0</li></div>
|
||||
28
src/main/java/leetcode/editor/cn/doc/content/MeetingRooms.md
Normal file
28
src/main/java/leetcode/editor/cn/doc/content/MeetingRooms.md
Normal file
@ -0,0 +1,28 @@
|
||||
<p>给定一个会议时间安排的数组 <code>intervals</code> ，每个会议时间都会包括开始和结束的时间 <code>intervals[i] = [start<sub>i</sub>, end<sub>i</sub>]</code> ，请你判断一个人是否能够参加这里面的全部会议。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>intervals = [[0,30],[5,10],[15,20]]
|
||||
<strong>输出</strong>：false
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>intervals = [[7,10],[2,4]]
|
||||
<strong>输出</strong>：true
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= intervals.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>intervals[i].length == 2</code></li>
|
||||
<li><code>0 <= start<sub>i</sub> < end<sub>i</sub> <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>排序</li></div></div><br><div><li>👍 117</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,37 @@
|
||||
<p>给你两个字符串 <code>current</code> 和 <code>correct</code> ，表示两个 <strong>24 小时制时间</strong> 。</p>
|
||||
|
||||
<p><strong>24 小时制时间</strong> 按 <code>"HH:MM"</code> 进行格式化，其中 <code>HH</code> 在 <code>00</code> 和 <code>23</code> 之间，而 <code>MM</code> 在 <code>00</code> 和 <code>59</code> 之间。最早的 24 小时制时间为 <code>00:00</code> ，最晚的是 <code>23:59</code> 。</p>
|
||||
|
||||
<p>在一步操作中，你可以将 <code>current</code> 这个时间增加 <code>1</code>、<code>5</code>、<code>15</code> 或 <code>60</code> 分钟。你可以执行这一操作 <strong>任意</strong> 次数。</p>
|
||||
|
||||
<p>返回将 <code>current</code><em> </em>转化为<em> </em><code>correct</code> 需要的 <strong>最少操作数</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>current = "02:30", correct = "04:35"
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：
|
||||
</strong>可以按下述 3 步操作将 current 转换为 correct ：
|
||||
- 为 current 加 60 分钟，current 变为 "03:30" 。
|
||||
- 为 current 加 60 分钟，current 变为 "04:30" 。
|
||||
- 为 current 加 5 分钟，current 变为 "04:35" 。
|
||||
可以证明，无法用少于 3 步操作将 current 转化为 correct 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>current = "11:00", correct = "11:01"
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>只需要为 current 加一分钟，所以最小操作数是 1 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>current</code> 和 <code>correct</code> 都符合 <code>"HH:MM"</code> 格式</li>
|
||||
<li><code>current <= correct</code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>贪心</li><li>字符串</li></div></div><br><div><li>👍 7</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,38 @@
|
||||
<p>我们要把给定的字符串 <code>S</code> 从左到右写到每一行上，每一行的最大宽度为100个单位，如果我们在写某个字母的时候会使这行超过了100 个单位，那么我们应该把这个字母写到下一行。我们给定了一个数组 <code>widths</code> ，这个数组 widths[0] 代表 'a' 需要的单位， widths[1] 代表 'b' 需要的单位，...， widths[25] 代表 'z' 需要的单位。</p>
|
||||
|
||||
<p>现在回答两个问题：至少多少行能放下<code>S</code>，以及最后一行使用的宽度是多少个单位？将你的答案作为长度为2的整数列表返回。</p>
|
||||
|
||||
<pre>
|
||||
<strong>示例 1:</strong>
|
||||
<strong>输入:</strong>
|
||||
widths = [10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]
|
||||
S = "abcdefghijklmnopqrstuvwxyz"
|
||||
<strong>输出:</strong> [3, 60]
|
||||
<strong>解释:
|
||||
</strong>所有的字符拥有相同的占用单位10。所以书写所有的26个字母，
|
||||
我们需要2个整行和占用60个单位的一行。
|
||||
</pre>
|
||||
|
||||
<pre>
|
||||
<strong>示例 2:</strong>
|
||||
<strong>输入:</strong>
|
||||
widths = [4,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]
|
||||
S = "bbbcccdddaaa"
|
||||
<strong>输出:</strong> [2, 4]
|
||||
<strong>解释:
|
||||
</strong>除去字母'a'所有的字符都是相同的单位10，并且字符串 "bbbcccdddaa" 将会覆盖 9 * 10 + 2 * 4 = 98 个单位.
|
||||
最后一个字母 'a' 将会被写到第二行，因为第一行只剩下2个单位了。
|
||||
所以，这个答案是2行，第二行有4个单位宽度。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>注:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>字符串 <code>S</code> 的长度在 [1, 1000] 的范围。</li>
|
||||
<li><code>S</code> 只包含小写字母。</li>
|
||||
<li><code>widths</code> 是长度为 <code>26</code>的数组。</li>
|
||||
<li><code>widths[i]</code> 值的范围在 <code>[2, 10]</code>。</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>字符串</li></div></div><br><div><li>👍 69</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,17 @@
|
||||
<p>给定一个字符串，判断该字符串中是否可以通过重新排列组合，形成一个回文字符串。</p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> <code>"code"</code>
|
||||
<strong>输出:</strong> false</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> <code>"aab"</code>
|
||||
<strong>输出:</strong> true</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> <code>"carerac"</code>
|
||||
<strong>输出:</strong> true</pre>
|
||||
<div><div>Related Topics</div><div><li>位运算</li><li>哈希表</li><li>字符串</li></div></div><br><div><li>👍 59</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,42 @@
|
||||
<p>给定一个整数数组 <code>nums</code>，处理以下类型的多个查询:</p>
|
||||
|
||||
<ol>
|
||||
<li>计算索引 <code>left</code> 和 <code>right</code> （包含 <code>left</code> 和 <code>right</code>）之间的 <code>nums</code> 元素的 <strong>和</strong> ，其中 <code>left <= right</code></li>
|
||||
</ol>
|
||||
|
||||
<p>实现 <code>NumArray</code> 类：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>NumArray(int[] nums)</code> 使用数组 <code>nums</code> 初始化对象</li>
|
||||
<li><code>int sumRange(int i, int j)</code> 返回数组 <code>nums</code> 中索引 <code>left</code> 和 <code>right</code> 之间的元素的 <strong>总和</strong> ，包含 <code>left</code> 和 <code>right</code> 两点（也就是 <code>nums[left] + nums[left + 1] + ... + nums[right]</code> )</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>
|
||||
["NumArray", "sumRange", "sumRange", "sumRange"]
|
||||
[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]
|
||||
<strong>输出：
|
||||
</strong>[null, 1, -1, -3]
|
||||
|
||||
<strong>解释：</strong>
|
||||
NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
|
||||
numArray.sumRange(0, 2); // return 1 ((-2) + 0 + 3)
|
||||
numArray.sumRange(2, 5); // return -1 (3 + (-5) + 2 + (-1))
|
||||
numArray.sumRange(0, 5); // return -3 ((-2) + 0 + 3 + (-5) + 2 + (-1))
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= i <= j < nums.length</code></li>
|
||||
<li>最多调用 <code>10<sup>4</sup></code> 次 <code>sumRange</code><strong> </strong>方法</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>设计</li><li>数组</li><li>前缀和</li></div></div><br><div><li>👍 443</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,38 @@
|
||||
<p>给定一个非空的字符串<meta charset="UTF-8" /> <code>s</code> ，检查是否可以通过由它的一个子串重复多次构成。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> s = "abab"
|
||||
<strong>输出:</strong> true
|
||||
<strong>解释:</strong> 可由子串 "ab" 重复两次构成。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> s = "aba"
|
||||
<strong>输出:</strong> false
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> s = "abcabcabcabc"
|
||||
<strong>输出:</strong> true
|
||||
<strong>解释:</strong> 可由子串 "abc" 重复四次构成。 (或子串 "abcabc" 重复两次构成。)
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><b>提示：</b></p>
|
||||
|
||||
<p><meta charset="UTF-8" /></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>s</code> 由小写英文字母组成</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>字符串</li><li>字符串匹配</li></div></div><br><div><li>👍 676</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,43 @@
|
||||
<p>给你一个 <code>m x n</code> 的整数网格 <code>accounts</code> ，其中 <code>accounts[i][j]</code> 是第 <code>i<sup></sup></code> 位客户在第 <code>j</code> 家银行托管的资产数量。返回最富有客户所拥有的 <strong>资产总量</strong> 。</p>
|
||||
|
||||
<p>客户的 <strong>资产总量</strong> 就是他们在各家银行托管的资产数量之和。最富有客户就是 <strong>资产总量</strong> 最大的客户。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>accounts = [[1,2,3],[3,2,1]]
|
||||
<strong>输出：</strong>6
|
||||
<strong>解释：</strong>
|
||||
<code>第 1 位客户的资产总量 = 1 + 2 + 3 = 6
|
||||
第 2 位客户的资产总量 = 3 + 2 + 1 = 6
|
||||
</code>两位客户都是最富有的，资产总量都是 6 ，所以返回 6 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>accounts = [[1,5],[7,3],[3,5]]
|
||||
<strong>输出：</strong>10
|
||||
<strong>解释：</strong>
|
||||
<code>第 1 位客户的资产总量</code> = 6
|
||||
<code>第 2 位客户的资产总量</code> = 10
|
||||
<code>第 3 位客户的资产总量</code> = 8
|
||||
第 2 位客户是最富有的，资产总量是 10</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>accounts = [[2,8,7],[7,1,3],[1,9,5]]
|
||||
<strong>输出：</strong>17
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == accounts.length</code></li>
|
||||
<li><code>n == accounts[i].length</code></li>
|
||||
<li><code>1 <= m, n <= 50</code></li>
|
||||
<li><code>1 <= accounts[i][j] <= 100</code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>矩阵</li></div></div><br><div><li>👍 53</li><li>👎 0</li></div>
|
||||
55
src/main/java/leetcode/editor/cn/doc/content/RingsAndRods.md
Normal file
55
src/main/java/leetcode/editor/cn/doc/content/RingsAndRods.md
Normal file
@ -0,0 +1,55 @@
|
||||
<p>总计有 <code>n</code> 个环，环的颜色可以是红、绿、蓝中的一种。这些环分布穿在 10 根编号为 <code>0</code> 到 <code>9</code> 的杆上。</p>
|
||||
|
||||
<p>给你一个长度为 <code>2n</code> 的字符串 <code>rings</code> ，表示这 <code>n</code> 个环在杆上的分布。<code>rings</code> 中每两个字符形成一个 <strong>颜色位置对</strong> ，用于描述每个环：</p>
|
||||
|
||||
<ul>
|
||||
<li>第 <code>i</code> 对中的 <strong>第一个</strong> 字符表示第 <code>i</code> 个环的 <strong>颜色</strong>（<code>'R'</code>、<code>'G'</code>、<code>'B'</code>）。</li>
|
||||
<li>第 <code>i</code> 对中的 <strong>第二个</strong> 字符表示第 <code>i</code> 个环的 <strong>位置</strong>，也就是位于哪根杆上（<code>'0'</code> 到 <code>'9'</code>）。</li>
|
||||
</ul>
|
||||
|
||||
<p>例如，<code>"R3G2B1"</code> 表示：共有 <code>n == 3</code> 个环，红色的环在编号为 3 的杆上，绿色的环在编号为 2 的杆上，蓝色的环在编号为 1 的杆上。</p>
|
||||
|
||||
<p>找出所有集齐 <strong>全部三种颜色</strong> 环的杆，并返回这种杆的数量。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/11/23/ex1final.png" style="width: 258px; height: 130px;">
|
||||
<pre><strong>输入：</strong>rings = "B0B6G0R6R0R6G9"
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>
|
||||
- 编号 0 的杆上有 3 个环，集齐全部颜色：红、绿、蓝。
|
||||
- 编号 6 的杆上有 3 个环，但只有红、蓝两种颜色。
|
||||
- 编号 9 的杆上只有 1 个绿色环。
|
||||
因此，集齐全部三种颜色环的杆的数目为 1 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/11/23/ex2final.png" style="width: 266px; height: 130px;">
|
||||
<pre><strong>输入：</strong>rings = "B0R0G0R9R0B0G0"
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>
|
||||
- 编号 0 的杆上有 6 个环，集齐全部颜色：红、绿、蓝。
|
||||
- 编号 9 的杆上只有 1 个红色环。
|
||||
因此，集齐全部三种颜色环的杆的数目为 1 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>rings = "G4"
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>
|
||||
只给了一个环，因此，不存在集齐全部三种颜色环的杆。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>rings.length == 2 * n</code></li>
|
||||
<li><code>1 <= n <= 100</code></li>
|
||||
<li>如 <code>i</code> 是 <strong>偶数</strong> ，则 <code>rings[i]</code> 的值可以取 <code>'R'</code>、<code>'G'</code> 或 <code>'B'</code>（下标从 <strong>0</strong> 开始计数）</li>
|
||||
<li>如 <code>i</code> 是 <strong>奇数</strong> ，则 <code>rings[i]</code> 的值可以取 <code>'0'</code> 到 <code>'9'</code> 中的一个数字（下标从 <strong>0</strong> 开始计数）</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>哈希表</li><li>字符串</li></div></div><br><div><li>👍 13</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,29 @@
|
||||
<p>给定一个字符串数组 <code>wordDict</code> 和两个已经存在于该数组中的不同的字符串 <code>word1</code> 和 <code>word2</code> 。返回列表中这两个单词之间的最短距离。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> wordsDict = ["practice", "makes", "perfect", "coding", "makes"], word1 = "coding", word2 = "practice"
|
||||
<strong>输出:</strong> 3
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> wordsDict = ["practice", "makes", "perfect", "coding", "makes"], word1 = "makes", word2 = "coding"
|
||||
<strong>输出:</strong> 1</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示:</strong><meta charset="UTF-8" /></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= wordsDict.length <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= wordsDict[i].length <= 10</code></li>
|
||||
<li><code>wordsDict[i]</code> 由小写英文字母组成</li>
|
||||
<li><code>word1</code> 和 <code>word2</code> 在 <code>wordsDict</code> 中</li>
|
||||
<li><code>word1 != word2</code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>字符串</li></div></div><br><div><li>👍 90</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,47 @@
|
||||
<p>已知函数 <code>signFunc(x)</code> 将会根据 <code>x</code> 的正负返回特定值：</p>
|
||||
|
||||
<ul>
|
||||
<li>如果 <code>x</code> 是正数，返回 <code>1</code> 。</li>
|
||||
<li>如果 <code>x</code> 是负数，返回 <code>-1</code> 。</li>
|
||||
<li>如果 <code>x</code> 是等于 <code>0</code> ，返回 <code>0</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>给你一个整数数组 <code>nums</code> 。令 <code>product</code> 为数组 <code>nums</code> 中所有元素值的乘积。</p>
|
||||
|
||||
<p>返回 <code>signFunc(product)</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [-1,-2,-3,-4,3,2,1]
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>数组中所有值的乘积是 144 ，且 signFunc(144) = 1
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,5,0,2,-3]
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>数组中所有值的乘积是 0 ，且 signFunc(0) = 0
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [-1,1,-1,1,-1]
|
||||
<strong>输出：</strong>-1
|
||||
<strong>解释：</strong>数组中所有值的乘积是 -1 ，且 signFunc(-1) = -1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 1000</code></li>
|
||||
<li><code>-100 <= nums[i] <= 100</code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>数学</li></div></div><br><div><li>👍 20</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,32 @@
|
||||
<p>给你一个整数 <code>n</code>，请你帮忙计算并返回该整数「各位数字之积」与「各位数字之和」的差。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>n = 234
|
||||
<strong>输出：</strong>15
|
||||
<strong>解释：</strong>
|
||||
各位数之积 = 2 * 3 * 4 = 24
|
||||
各位数之和 = 2 + 3 + 4 = 9
|
||||
结果 = 24 - 9 = 15
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>n = 4421
|
||||
<strong>输出：</strong>21
|
||||
<strong>解释：
|
||||
</strong>各位数之积 = 4 * 4 * 2 * 1 = 32
|
||||
各位数之和 = 4 + 4 + 2 + 1 = 11
|
||||
结果 = 32 - 11 = 21
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10^5</code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数学</li></div></div><br><div><li>👍 81</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,28 @@
|
||||
<p>给定一个 <strong>正整数</strong> <code>num</code> ，编写一个函数，如果 <code>num</code> 是一个完全平方数，则返回 <code>true</code> ，否则返回 <code>false</code> 。</p>
|
||||
|
||||
<p><strong>进阶：不要</strong> 使用任何内置的库函数，如 <code>sqrt</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>num = 16
|
||||
<strong>输出：</strong>true
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>num = 14
|
||||
<strong>输出：</strong>false
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= num <= 2^31 - 1</code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数学</li><li>二分查找</li></div></div><br><div><li>👍 371</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,52 @@
|
||||
<p>字符串可以用 <strong>缩写</strong> 进行表示，<strong>缩写</strong> 的方法是将任意数量的 <strong>不相邻</strong> 的子字符串替换为相应子串的长度。例如，字符串 <code>"substitution"</code> 可以缩写为（不止这几种方法）：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>"s10n"</code> (<code>"s <em><strong>ubstitutio</strong></em> n"</code>)</li>
|
||||
<li><code>"sub4u4"</code> (<code>"sub <em><strong>stit</strong></em> u <em><strong>tion</strong></em>"</code>)</li>
|
||||
<li><code>"12"</code> (<code>"<em><strong>substitution</strong></em>"</code>)</li>
|
||||
<li><code>"su3i1u2on"</code> (<code>"su <em><strong>bst</strong></em> i <em><strong>t</strong></em> u <em><strong>ti</strong></em> on"</code>)</li>
|
||||
<li><code>"substitution"</code> (没有替换子字符串)</li>
|
||||
</ul>
|
||||
|
||||
<p>下列是不合法的缩写：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>"s55n"</code> (<code>"s <u>ubsti</u> <u>tutio</u> n"</code>，两处缩写相邻)</li>
|
||||
<li><code>"s010n"</code> (缩写存在前导零)</li>
|
||||
<li><code>"s0ubstitution"</code> (缩写是一个空字符串)</li>
|
||||
</ul>
|
||||
|
||||
<p>给你一个字符串单词 <code>word</code> 和一个缩写 <code>abbr</code> ，判断这个缩写是否可以是给定单词的缩写。</p>
|
||||
|
||||
<p><strong>子字符串</strong>是字符串中连续的<strong>非空</strong>字符序列。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>word = "internationalization", abbr = "i12iz4n"
|
||||
<strong>输出：</strong>true
|
||||
<strong>解释：</strong>单词 "internationalization" 可以缩写为 "i12iz4n" ("i <em><strong>nternational</strong></em> iz <em><strong>atio</strong></em> n") 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>word = "apple", abbr = "a2e"
|
||||
<strong>输出：</strong>false
|
||||
<strong>解释：</strong>单词 "apple" 无法缩写为 "a2e" 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= word.length <= 20</code></li>
|
||||
<li><code>word</code> 仅由小写英文字母组成</li>
|
||||
<li><code>1 <= abbr.length <= 10</code></li>
|
||||
<li><code>abbr</code> 由小写英文字母和数字组成</li>
|
||||
<li><code>abbr</code> 中的所有数字均符合 32-bit 整数范围</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>双指针</li><li>字符串</li></div></div><br><div><li>👍 39</li><li>👎 0</li></div>
|
||||
Loading…
Reference in New Issue
Block a user