feat: add 007

Author: Blankj

README.md

@@ -1,6 +1,6 @@
 # awesome-java-leetcode
 
-如今我是一名Android Developer，大学曾是一名ACMer，如今工作了，不想让算法淡出我的记忆，故重拾LeetCode之Algorithm，语言选择的是Java，题库会一点点完善起来，按简单，中等，困难分类，相应难度下按题号排序，工程代码在[project][project]目录中，相关解题都在[note][note]目录中，欢迎star。
+我如今是一名Android Developer，大学的我曾是一名ACMer，为了不想让算法淡出我的记忆，故重拾LeetCode之Algorithm，语言选择的是Java，题库会一点点完善起来，按简单，中等，困难分类，相应难度下按题号排序，工程代码在[project][project]目录中，相关解题都在[note][note]目录中，欢迎star。
 
 ## Easy
 

note/001/README.md

@@ -2,11 +2,11 @@
 
 ## Description
 
-Given an array of integers, return indices of the two numbers such that they add up to a specific target.
+Given an array of integers, return **indices** of the two numbers such that they add up to a specific target.
 
-You may assume that each input would have exactly one solution, and you may not use the same element twice.
+You may assume that each input would have ***exactly*** one solution, and you may not use the same element twice.
 
-Example:
+**Example:**
 
 ```
 Given nums = [2, 7, 11, 15], target = 9,
@@ -15,9 +15,12 @@ Because nums[0] + nums[1] = 2 + 7 = 9,
 return [0, 1].
 ```
 
+**Tag：** Array, Hash Table
+
+
 ## 思路0
 
-题意是让你从给定的数组中找到两个元素的和为指定值的两个索引，最容易的当然是循环两次，复杂度为O(n^2)，首次提交居然是2ms，打败了100%的提交，谜一样的结果，之后再次提交就再也没跑到过2ms了。
+题意是让你从给定的数组中找到两个元素的和为指定值的两个索引，最容易的当然是循环两次，复杂度为`O(n^2)`，首次提交居然是2ms，打败了100%的提交，谜一样的结果，之后再次提交就再也没跑到过2ms了。
 
 ``` java
 public class Solution {
@@ -38,9 +41,9 @@ public class Solution {
 
 ## 思路1
 
-利用HashMap作为存储，键为目标值减去当前元素值，索引为值，比如i = 0时，此时首先要判断nums[0] = 2是否在map中，如果不存在，那么插入键值对key = 9 - 2 = 7, value = 0，之后当i = 1时，此时判断nums[1] = 7已存在于map中，那么取出该value = 0作为第一个返回值，当前i作为第二个返回值，具体代码如下所示。
+利用HashMap作为存储，键为目标值减去当前元素值，索引为值，比如`i = 0`时，此时首先要判断`nums[0] = 2`是否在map中，如果不存在，那么插入键值对`key = 9 - 2 = 7, value = 0`，之后当`i = 1`时，此时判断`nums[1] = 7`已存在于map中，那么取出该`value = 0`作为第一个返回值，当前`i`作为第二个返回值，具体代码如下所示。
 
-```
+``` java
 class Solution {
     public int[] twoSum(int[] nums, int target) {
         int len = nums.length;
@@ -54,4 +57,4 @@ class Solution {
         return null;
     }
 }
-```
+```

note/007/007.md

@@ -0,0 +1,44 @@
+# Reverse Integer
+
+## Description
+
+Reverse digits of an integer.
+
+**Example1:** x = 123, return 321
+
+**Example2:** x = -123, return -321
+
+**Spoilers：**
+
+**Have you thought about this?**
+
+Here are some good questions to ask before coding. Bonus points for you if you have already thought through this!
+
+If the integer's last digit is 0, what should the output be? ie, cases such as 10, 100.
+
+Did you notice that the reversed integer might overflow? Assume the input is a 32-bit integer, then the reverse of 1000000003 overflows. How should you handle such cases?
+
+For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.
+
+**Note:**
+
+The input is assumed to be a 32-bit signed integer. Your function should **return 0 when the reversed integer overflows**.
+
+**Tag：** Math
+
+
+## 思路
+
+题意很清楚，就是给你一个整型数，返回它的逆序整型数，而且有个小坑点，当它的逆序整型数溢出的话，那么就返回0
+，用我们代码表示的话可以求得结果保存在long中，最后把结果和整型的两个范围比较即可。
+
+``` java
+public class Solution {
+    public int reverse(int x) {
+        long res = 0;
+        for (; x != 0; x /= 10)
+            res = res * 10 + x % 10;
+        return res > Integer.MAX_VALUE || res < Integer.MIN_VALUE ? 0 : (int) res;
+    }
+}
+```

note/007/README.md

@@ -13,7 +13,11 @@
 
 public class _007 {
     public static void main(String[] args) {
-
+        Solution solution = new Solution();
+        System.out.println(solution.reverse(123));
+        System.out.println(solution.reverse(-123));
+        System.out.println(solution.reverse(100));
+        System.out.println(solution.reverse(1000000003));
     }
 }