let's go ! 2022.2.11

Author: roxie-23

Daily-record/2022.1.md

@@ -0,0 +1,49 @@
+## shell
+
+### 批量修改文件名
+
+想要统一文件名格式，比如批量删除前缀`leetcode`
+
+```shell
+$ ls 
+…………
+leetcode738-单调递增的数字.md
+leetcode746-使用最小花费爬楼梯.md
+leetcode75-颜色分类.md
+leetcode767-重构字符串.md
+leetcode832. 翻转图像.md
+leetcode834-树中距离之和.md
+leetcode842-将数组拆分成斐波那契序列.md
+leetcode860-柠檬水找零.md
+leetcode861-翻转矩阵后的得分.md
+leetcode888-公平的糖果棒交换.md
+leetcode922-按奇偶排序数组 II.md
+leetcode977-有序数组的平方.md
+
+$ rename 's/leetcode//' *.md && ls
+……
+75-颜色分类.md
+767-重构字符串.md
+832. 翻转图像.md
+834-树中距离之和.md
+842-将数组拆分成斐波那契序列.md
+860-柠檬水找零.md
+861-翻转矩阵后的得分.md
+888-公平的糖果棒交换.md
+922-按奇偶排序数组 II.md
+977-有序数组的平方.md
+
+$ rename 's/\-/\. /' *.md && ls 
+…………
+75. 颜色分类.md
+767. 重构字符串.md
+832. 翻转图像.md
+834. 树中距离之和.md
+842. 将数组拆分成斐波那契序列.md
+860. 柠檬水找零.md
+861. 翻转矩阵后的得分.md
+888. 公平的糖果棒交换.md
+922. 按奇偶排序数组 II.md
+977. 有序数组的平方.md
+```
+

每日一题/leetcode1-两数之和.md renamed to daily-problem/1. 两数之和.md

@@ -1,47 +1,47 @@
-#### [1. 两数之和](https://leetcode-cn.com/problems/two-sum/)
-
-给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
-
-你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
-
-```
-示例:
-
-给定 nums = [2, 7, 11, 15], target = 9
-
-因为 nums[0] + nums[1] = 2 + 7 = 9
-所以返回 [0, 1]
-```
-
-
-
-这道题本身如果通过暴力遍历的话也是很容易解决的，时间复杂度在 O(n2)。由于**哈希查找的时间复杂度为 O(1)**，所以可以利用哈希容器 map 降低时间复杂度
-
-- 遍历数组 nums，i 为当前下标，每个值都判断map中是否存在 target-nums[i] 的 key 值
-- 如果存在则找到了两个值，如果不存在则将当前的 (nums[i],i) 存入 map 中，继续遍历直到找到为止
-
-**动画图解：**
-
-![leetcode1](image/leetcode1.gif)
-
-```java
-class Solution {
-    public int[] twoSum(int[] nums, int target) {
-        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
-        //注意：不能调用自身两次，所以不能先把所有值加入map，再判断是否contain，这样没办法避免重复调用的情况
-        //解决办法：先判断是否contain，再加入map
-        for (int i = 0; i < nums.length; ++i) {
-            if (map.containsKey(target - nums[i])) {
-                return new int[]{map.get(target - nums[i]), i};
-            }
-            map.put(nums[i], i);
-        }
-        return new int[0];
-    }
-}
-```
-
-> 时间复杂度：O(N)，其中 N是数组中的元素数量。对于每一个元素 x，我们可以 O(1) 地寻找 target - x。
->
-> 空间复杂度：O(N)，其中 N 是数组中的元素数量。主要为哈希表的开销。
+#### [1. 两数之和](https://leetcode-cn.com/problems/two-sum/)
+
+给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
+
+你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
+
+```
+示例:
+
+给定 nums = [2, 7, 11, 15], target = 9
+
+因为 nums[0] + nums[1] = 2 + 7 = 9
+所以返回 [0, 1]
+```
+
+
+
+这道题本身如果通过暴力遍历的话也是很容易解决的，时间复杂度在 O(n2)。由于**哈希查找的时间复杂度为 O(1)**，所以可以利用哈希容器 map 降低时间复杂度
+
+- 遍历数组 nums，i 为当前下标，每个值都判断map中是否存在 target-nums[i] 的 key 值
+- 如果存在则找到了两个值，如果不存在则将当前的 (nums[i],i) 存入 map 中，继续遍历直到找到为止
+
+**动画图解：**
+
+![leetcode1](image/leetcode1.gif)
+
+```java
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
+        //注意：不能调用自身两次，所以不能先把所有值加入map，再判断是否contain，这样没办法避免重复调用的情况
+        //解决办法：先判断是否contain，再加入map
+        for (int i = 0; i < nums.length; ++i) {
+            if (map.containsKey(target - nums[i])) {
+                return new int[]{map.get(target - nums[i]), i};
+            }
+            map.put(nums[i], i);
+        }
+        return new int[0];
+    }
+}
+```
+
+> 时间复杂度：O(N)，其中 N是数组中的元素数量。对于每一个元素 x，我们可以 O(1) 地寻找 target - x。
+>
+> 空间复杂度：O(N)，其中 N 是数组中的元素数量。主要为哈希表的开销。
 >