diff --git a/.gitignore b/.gitignore
index f834df7..bf1471a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -41,4 +41,8 @@ RemoteSystemsTempFiles/
 .DS_Store
 .ds_store
 ._*
-Thumbs.db
\ No newline at end of file
+Thumbs.db
+
+### leetcode
+/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/all.json
+/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/translation.json
diff --git a/pom.xml b/pom.xml
index e847bda..ee8d578 100644
--- a/pom.xml
+++ b/pom.xml
@@ -23,8 +23,8 @@
             定义 maven-compiler-plugin 的 source & target 属性(java版本)
             如不定义且未在插件中定义source和target属性，3.8(20180726) 以前 默认 1.5，以后 默认 1.6
          -->
-        <maven.compiler.source>1.8</maven.compiler.source>
-        <maven.compiler.target>1.8</maven.compiler.target>
+        <maven.compiler.source>11</maven.compiler.source>
+        <maven.compiler.target>11</maven.compiler.target>
     </properties>
 
     <dependencies>
@@ -81,13 +81,13 @@
                         也可在此处自定义
                         如未定义，3.8(20180726) 以前 默认 1.5，以后 默认 1.6
                      -->
-                    <source>1.8</source>
+                    <source>11</source>
                     <!--
                         可用专属表达式定义： ${maven.compiler.target}
                         也可在此处自定义
                         如未定义，3.8(20180726) 以前 默认 1.5，以后 默认 1.6
                      -->
-                    <target>1.8</target>
+                    <target>11</target>
                     <!-- 默认值可用表达式定义： ${project.build.sourceEncoding}
                         也可用专属表达式定义： ${encoding}
                         也可在此处自定义
diff --git a/src/main/java/com/starriddle/starter/java/algorithm/other/Sort.java b/src/main/java/com/starriddle/starter/java/algorithm/other/Sort.java
new file mode 100644
index 0000000..45a6861
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/algorithm/other/Sort.java
@@ -0,0 +1,174 @@
+package com.starriddle.starter.java.algorithm.other;
+
+import java.util.Arrays;
+import java.util.Random;
+
+/**
+ * 十大经典排序算法
+ *
+ * 冒泡排序（Bubble Sort）
+ * 选择排序（Selection Sort）
+ * 插入排序（Insertion Sort）
+ * 希尔排序（Shell Sort）
+ * 归并排序（Merge Sort）
+ * 快速排序（Quick Sort）
+ * 堆排序（Heap Sort）
+ *
+ * 计数排序（Counting Sort）
+ * 桶排序（Bucket Sort）
+ * 基数排序（Radix Sort）
+ *
+ * @author CYL
+ * @date 2019-07-31
+ */
+public class Sort {
+
+    /**
+     * 重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。
+     * 走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。<p/>
+     *
+     * - 比较相邻的元素。如果第一个比第二个大，就交换它们两个；<br>
+     * - 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；<br>
+     * - 针对所有的元素重复以上的步骤，除了最后一个；<br>
+     * - 重复步骤1~3，直到排序完成。<p/>
+     *
+     * - 最佳情况：T(n) = O(n) <br>
+     * - 最差情况：T(n) = O(n²) <br>
+     * - 平均情况：T(n) = O(n²)
+     *
+     * @param array
+     * @return
+     */
+    public static int[] bubbleSort(int[] array) {
+        if (array.length <= 1) {
+            return array;
+        }
+        int temp;
+        for (int i = 0; i < array.length; i++) {
+            for (int j = 0; j < array.length - 1 - i; j++) {
+                if (array[j] > array[j+1]) {
+                    temp = array[j+1];
+                    array[j+1] = array[j];
+                    array[j] = temp;
+                }
+            }
+        }
+        return array;
+    }
+
+    /**
+     * 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
+     * 然后，再从剩余未排序元素中继续寻找最小（大）元素，放到已排序序列的末尾。
+     * 以此类推，直到所有元素均排序完毕。<p/>
+     *
+     * - 初始状态：无序区为R[1..n]，有序区为空；<br>
+     * - 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。
+     *   该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，
+     *   使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；<br>
+     * - n-1趟结束，数组有序化了。<p/>
+     *
+     * - 最佳情况：T(n) = O(n²) <br>
+     * - 最差情况：T(n) = O(n²) <br>
+     * - 平均情况：T(n) = O(n²)
+     *
+     * @param array
+     * @return
+     */
+    public static int[] selectionSort(int[] array) {
+        if (array.length <= 1) {
+            return array;
+        }
+        int index;
+        int temp;
+        for (int i = 0; i < array.length; i++) {
+            index = i;
+            for (int j = i+1; j < array.length; j++) {
+                if (array[index] > array[j]) {
+                    index = j;
+                }
+            }
+            if (index != i) {
+                temp = array[i];
+                array[i] = array[index];
+                array[index] = temp;
+            }
+        }
+        return array;
+    }
+
+    /**
+     * 通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。<p/>
+     *
+     * - 从第一个元素开始，该元素可以认为已经被排序；<br>
+     * - 取出下一个元素，在已经排序的元素序列中从后向前扫描；<br>
+     * - 如果该元素（已排序）大于新元素，将该元素移到下一位置；<br>
+     * - 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；<br>
+     * - 将新元素插入到该位置后；<br>
+     * - 重复步骤2~5。<p/>
+     *
+     * - 最佳情况：T(n) = O(n) <br>
+     * - 最坏情况：T(n) = O(n²) <br>
+     * - 平均情况：T(n) = O(n²)
+     *
+     * @param array
+     * @return
+     */
+    public static int[] insertionSort(int[] array) {
+        if (array.length <= 1) {
+            return array;
+        }
+        int current;
+        int index;
+        for (int i = 0; i < array.length - 1; i++) {
+            current = array[i+1];
+            for (index = i; index >= 0; index--) {
+                if (current >= array[index]) {
+                    break;
+                }
+                array[index+1] = array[index];
+            }
+            array[index+1] = current;
+        }
+        return array;
+    }
+
+    public static int[] shellSort(int[] array) {
+        int current;
+        int index;
+        for (int gap = array.length / 2; gap > 0; gap /= 2) {
+            for (int i = gap; i < array.length; i++) {
+                current = array[i];
+                for (index = i - gap; index >= 0; index -= gap ) {
+                    if (current >= array[index]) {
+                        break;
+                    }
+                    array[index + gap] = array[index];
+                }
+                array[index + gap] = current;
+            }
+        }
+        return array;
+    }
+
+    public static void main(String[] args) {
+        int[] array = new int[50];
+        Random random = new Random();
+        for (int i = 0; i < array.length; i++) {
+            array[i] = random.nextInt(100);
+        }
+        System.out.println(Arrays.toString(array));
+        long start = System.currentTimeMillis();
+        // 冒泡排序
+//        array = bubbleSort(array);
+        // 选择排序
+//        array = selectionSort(array);
+        // 插入排序
+//        array = insertionSort(array);
+        // 希尔排序
+        array = shellSort(array);
+        long end = System.currentTimeMillis();
+        System.out.println(Arrays.toString(array));
+        System.out.println("Duration Time: " + (end - start));
+    }
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0001.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0001.java
new file mode 100644
index 0000000..d670db9
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0001.java
@@ -0,0 +1,77 @@
+//给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 
+//
+// 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 
+//
+// 
+//
+// 示例: 
+//
+// 给定 nums = [2, 7, 11, 15], target = 9
+//
+//因为 nums[0] + nums[1] = 2 + 7 = 9
+//所以返回 [0, 1]
+// 
+// Related Topics 数组 哈希表 
+// 👍 8609 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+import java.util.Arrays;
+import java.util.HashMap;
+
+/**
+ * 1
+ * 两数之和
+ * two-sum
+ */
+public class L0001 {
+
+    public static void main(String[] args) {
+        L0001 instance = new L0001();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+        int[] nums = new int[]{2, 7, 11, 15};
+        int target = 9;
+        String out = Arrays.toString(solution.twoSum(nums, target));
+        System.out.println(out);
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        int[] ret = new int[2];
+
+        // 1. 双重循环
+        // for(int i = 0; i < nums.length; i ++) {
+        //     for(int j = i+1; j < nums.length; j ++) {
+        //         int sum = nums[i] + nums[j];
+        //         if(sum == target) {
+        //             ret[0] = i;
+        //             ret[1] = j
+        //             return ret;
+        //         }
+        //     }
+        // }
+
+        // 2. HashMap
+        HashMap<Integer, Integer> map = new HashMap<>();
+        for(int i = 0; i < nums.length; i ++) {
+            if(map.containsKey(nums[i])) {
+                ret[0] = map.get(nums[i]);
+                ret[1] = i;
+                return ret;
+            }
+            map.put(target - nums[i], i);
+        }
+
+        return ret;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
+
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0002.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0002.java
new file mode 100644
index 0000000..3c86a47
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0002.java
@@ -0,0 +1,96 @@
+//给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。 
+//
+// 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 
+//
+// 您可以假设除了数字 0 之外，这两个数都不会以 0 开头。 
+//
+// 示例： 
+//
+// 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
+//输出：7 -> 0 -> 8
+//原因：342 + 465 = 807
+// 
+// Related Topics 链表 数学 
+// 👍 4568 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 2
+ * 两数相加
+ * add-two-numbers
+ */
+public class L0002 {
+
+    public static void main(String[] args) {
+        L0002 instance = new L0002();
+        instance.test();
+    }
+
+    void test(){
+        Solution solution = new Solution();
+        // TODO
+        ListNode l1 = new ListNode(2);
+        l1.next = new ListNode(4);
+        l1.next.next = new ListNode(3);
+
+        ListNode l2 = new ListNode(7);
+        l2.next = new ListNode(0);
+        l2.next.next = new ListNode(8);
+
+        l1 = solution.addTwoNumbers(l1,l2);
+        System.out.print(l1.val);
+        while (l1.next != null) {
+            l1 = l1.next;
+            System.out.print(" -> " + l1.val);
+        }
+        System.out.println();
+    }
+
+    class ListNode {
+        int val;
+        ListNode next;
+        ListNode(int x) { val = x; }
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        ListNode node = new ListNode(0);
+        node.next = new ListNode(0);
+        ListNode list = node.next;
+        do {
+            int v1 = 0;
+            if(l1 != null) {
+                v1 = l1.val;
+                l1 = l1.next;
+            }
+            int v2 = 0;
+            if(l2 != null) {
+                v2 = l2.val;
+                l2 = l2.next;
+            }
+            if(node.next == null) {
+                node.next = new ListNode(0);
+            }
+            node = node.next;
+            int sum = node.val + v1 + v2;
+            node.val = sum % 10;
+            if(sum >= 10) {
+                node.next = new ListNode(1);
+            }
+        } while(l1 != null || l2 != null);
+        return list;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0003.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0003.java
new file mode 100644
index 0000000..4dad784
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0003.java
@@ -0,0 +1,74 @@
+//给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。 
+//
+// 示例 1: 
+//
+// 输入: "abcabcbb"
+//输出: 3 
+//解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
+// 
+//
+// 示例 2: 
+//
+// 输入: "bbbbb"
+//输出: 1
+//解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
+// 
+//
+// 示例 3: 
+//
+// 输入: "pwwkew"
+//输出: 3
+//解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
+//     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
+// 
+// Related Topics 哈希表 双指针 字符串 Sliding Window 
+// 👍 3948 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+import java.util.HashMap;
+
+/**
+ * 3
+ * 无重复字符的最长子串
+ * longest-substring-without-repeating-characters
+ */
+public class L0003 {
+
+    public static void main(String[] args) {
+        L0003 instance = new L0003();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+        String s = "pwwkew";
+        System.out.println(solution.lengthOfLongestSubstring(s));
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int lengthOfLongestSubstring(String s) {
+        int start = 0, maxLength = 0, size = s.length();
+        HashMap<Character, Integer> map = new HashMap<>();
+        for (int i = 0; i < size; i ++) {
+            char c = s.charAt(i);
+            if(map.containsKey(c)) {
+                int index = map.get(c);
+                if(index >= start) {
+                    maxLength = Math.max((i - start), maxLength);
+                    start = index +1;
+                    if(maxLength >= (size - start)) {
+                        return maxLength;
+                    }
+                }
+            }
+            map.put(s.charAt(i), i);
+        }
+        return size - start;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0006.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0006.java
new file mode 100644
index 0000000..9fa86b6
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0006.java
@@ -0,0 +1,83 @@
+//将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。 
+//
+// 比如输入字符串为 "LEETCODEISHIRING" 行数为 3 时，排列如下： 
+//
+//L   C   I   R
+//E T O E S I I G
+//E   D   H   N
+// 
+//
+// 之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："LCIRETOESIIGEDHN"。 
+//
+// 请你实现这个将字符串进行指定行数变换的函数： 
+//
+// string convert(string s, int numRows); 
+//
+// 示例 1: 
+//
+// 输入: s = "LEETCODEISHIRING", numRows = 3
+//输出: "LCIRETOESIIGEDHN"
+// 
+//
+// 示例 2: 
+//
+// 输入: s = "LEETCODEISHIRING", numRows = 4
+//输出: "LDREOEIIECIHNTSG"
+//解释:
+//
+//L     D     R
+//E   O E   I I
+//E C   I H   N
+//T     S     G 
+// Related Topics 字符串 
+// 👍 739 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 6
+ * Z 字形变换
+ * zigzag-conversion
+ */
+public class L0006 {
+
+    public static void main(String[] args) {
+        L0006 instance = new L0006();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+        String s= "LEETCODEISHIRING";
+        int numRows = 4;
+        String ret = "LDREOEIIECIHNTSG";
+        System.out.println(ret.equals(solution.convert(s, numRows)));
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public String convert(String s, int numRows) {
+        StringBuilder[] rows = new StringBuilder[numRows];
+        if (s == null || s.length() <= 2 || numRows < 2 || numRows >= s.length()) {
+            return s;
+        }
+        for (int row = 0; row < numRows; row++) {
+            rows[row] = new StringBuilder().append(s.charAt(row));
+        }
+        for (int index = numRows, row = numRows -2, step = -1; index < s.length(); index++) {
+            rows[row].append(s.charAt(index));
+            if (row == 0 || row == numRows - 1) {
+                step = -step;
+            }
+            row += step;
+        }
+        for (int row = 1; row < numRows; row++) {
+            rows[row] = rows[0].append(rows[row]);
+        }
+        return rows[0].toString();
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0007.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0007.java
new file mode 100644
index 0000000..6242b0e
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0007.java
@@ -0,0 +1,69 @@
+//给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。 
+//
+// 示例 1: 
+//
+// 输入: 123
+//输出: 321
+// 
+//
+// 示例 2: 
+//
+// 输入: -123
+//输出: -321
+// 
+//
+// 示例 3: 
+//
+// 输入: 120
+//输出: 21
+// 
+//
+// 注意: 
+//
+// 假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。 
+// Related Topics 数学 
+// 👍 2008 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 7
+ * 整数反转
+ * reverse-integer
+ */
+public class L0007 {
+
+    public static void main(String[] args) {
+        L0007 instance = new L0007();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int reverse(int x) {
+        long from = x, to = 0;
+        int flag = 1;
+        if (from<0) {
+            from = -from;
+            flag = -flag;
+        }
+        do {
+            long num = from % 10;
+            from /= 10;
+            to = to*10 + num;
+        } while (from != 0);
+        to *= flag;
+        if (to > Integer.MAX_VALUE || to < Integer.MIN_VALUE) {
+            to = 0;
+        }
+        return (int)to;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0009.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0009.java
new file mode 100644
index 0000000..166bdd3
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0009.java
@@ -0,0 +1,96 @@
+//判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。 
+//
+// 示例 1: 
+//
+// 输入: 121
+//输出: true
+// 
+//
+// 示例 2: 
+//
+// 输入: -121
+//输出: false
+//解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
+// 
+//
+// 示例 3: 
+//
+// 输入: 10
+//输出: false
+//解释: 从右向左读, 为 01 。因此它不是一个回文数。
+// 
+//
+// 进阶: 
+//
+// 你能不将整数转为字符串来解决这个问题吗？ 
+// Related Topics 数学 
+// 👍 1141 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 9
+ * 回文数
+ * palindrome-number
+ */
+public class L0009 {
+
+    public static void main(String[] args) {
+        L0009 instance = new L0009();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public boolean isPalindrome(int x) {
+
+        // 数字处理
+//        if (x < 0) {
+//            return false;
+//        }
+//        int y = 0, tmp = x;
+//        while (tmp > 0) {
+//             y = y * 10 + (tmp % 10);
+//             tmp /= 10;
+//        }
+//        return y == x;
+
+        // 字符串处理
+//        if (x < 0) {
+//            return false;
+//        }
+//        String str = String.valueOf(x);
+//        int len = str.length();
+//        for (int index = 0; index < len / 2; index++) {
+//            if(str.charAt(index) != str.charAt(len -1 -index)) {
+//                return false;
+//            }
+//        }
+//        return true;
+
+        // 数字处理 2
+        if (x < 0) {
+            return false;
+        }
+        if (x < 10) {
+            return true;
+        }
+        if (x % 10 == 0) {
+            return false;
+        }
+        int y = 0;
+        while (x > y) {
+             y = y * 10 + (x % 10);
+             x /= 10;
+        }
+        return x == y || x == y / 10;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0012.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0012.java
new file mode 100644
index 0000000..291f8bf
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0012.java
@@ -0,0 +1,124 @@
+//罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。 
+//
+// 字符          数值
+//I             1
+//V             5
+//X             10
+//L             50
+//C             100
+//D             500
+//M             1000 
+//
+// 例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + I
+//I 。 
+//
+// 通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5
+// 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况： 
+//
+// 
+// I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。 
+// X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
+// C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。 
+// 
+//
+// 给定一个整数，将其转为罗马数字。输入确保在 1 到 3999 的范围内。 
+//
+// 示例 1: 
+//
+// 输入: 3
+//输出: "III" 
+//
+// 示例 2: 
+//
+// 输入: 4
+//输出: "IV" 
+//
+// 示例 3: 
+//
+// 输入: 9
+//输出: "IX" 
+//
+// 示例 4: 
+//
+// 输入: 58
+//输出: "LVIII"
+//解释: L = 50, V = 5, III = 3.
+// 
+//
+// 示例 5: 
+//
+// 输入: 1994
+//输出: "MCMXCIV"
+//解释: M = 1000, CM = 900, XC = 90, IV = 4. 
+// Related Topics 数学 字符串 
+// 👍 364 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 12
+ * 整数转罗马数字
+ * integer-to-roman
+ */
+public class L0012 {
+
+    public static void main(String[] args) {
+        L0012 instance = new L0012();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+        int num = 1994;
+        System.out.println(solution.intToRoman(num));
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public String intToRoman(int num) {
+        String[][] roman = new String[][]{{"I","V"},{"X","L"},{"C","D"},{"M"}};
+        StringBuilder ret = new StringBuilder();
+        for (int i = 0; i < 4 && num > 0; i++, num /= 10) {
+            String str = null;
+            switch (num % 10) {
+                case 9:
+                    str = roman[i][0] + roman[i+1][0];
+                    break;
+                case 8:
+                    str = roman[i][1] + roman[i][0] + roman[i][0] + roman[i][0];
+                    break;
+                case 7:
+                    str = roman[i][1] + roman[i][0] + roman[i][0];
+                    break;
+                case 6:
+                    str = roman[i][1] + roman[i][0];
+                    break;
+                case 5:
+                    str = roman[i][1];
+                    break;
+                case 4:
+                    str = roman[i][0] + roman[i][1];
+                    break;
+                case 3:
+                    str = roman[i][0] + roman[i][0] + roman[i][0];
+                    break;
+                case 2:
+                    str = roman[i][0] + roman[i][0];
+                    break;
+                case 1:
+                    str = roman[i][0];
+                    break;
+                default:
+                    break;
+            }
+            if (str != null) {
+                ret.insert(0, str);
+            }
+        }
+        return ret.toString();
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0013.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0013.java
new file mode 100644
index 0000000..0ddf18f
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0013.java
@@ -0,0 +1,129 @@
+//罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。 
+//
+// 字符          数值
+//I             1
+//V             5
+//X             10
+//L             50
+//C             100
+//D             500
+//M             1000 
+//
+// 例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + I
+//I 。 
+//
+// 通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5
+// 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况： 
+//
+// 
+// I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。 
+// X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
+// C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。 
+// 
+//
+// 给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。 
+//
+// 示例 1: 
+//
+// 输入: "III"
+//输出: 3 
+//
+// 示例 2: 
+//
+// 输入: "IV"
+//输出: 4 
+//
+// 示例 3: 
+//
+// 输入: "IX"
+//输出: 9 
+//
+// 示例 4: 
+//
+// 输入: "LVIII"
+//输出: 58
+//解释: L = 50, V= 5, III = 3.
+// 
+//
+// 示例 5: 
+//
+// 输入: "MCMXCIV"
+//输出: 1994
+//解释: M = 1000, CM = 900, XC = 90, IV = 4. 
+// Related Topics 数学 字符串 
+// 👍 971 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 13
+ * 罗马数字转整数
+ * roman-to-integer
+ */
+public class L0013 {
+
+    public static void main(String[] args) {
+        L0013 instance = new L0013();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int romanToInt(String s) {
+        int number = 0;
+        for (int index = 0; index < s.length(); index++) {
+            switch (s.charAt(index)) {
+                case 'I':
+                    if (index != (s.length()-1)) {
+                        char next = s.charAt(index+1);
+                        if ((next == 'V' || next == 'X')) {
+                            number -= 1;
+                            break;
+                        }
+                    }
+                    number += 1;
+                    break;
+                case 'V':
+                    number += 5;
+                    break;
+                case 'X':
+                    if (index != (s.length()-1)) {
+                        char next = s.charAt(index+1);
+                        if ((next == 'L' || next == 'C')) {
+                            number -= 10;
+                            break;
+                        }
+                    }
+                    number += 10;
+                    break;
+                case 'L':
+                    number += 50;
+                    break;
+                case 'C':
+                    if (index != (s.length()-1)) {
+                        char next = s.charAt(index+1);
+                        if ((next == 'D' || next == 'M')) {
+                            number -= 100;
+                            break;
+                        }
+                    }
+                    number += 100;
+                    break;
+                case 'D':
+                    number += 500;
+                    break;
+                default:
+                    number += 1000;
+            }
+        }
+        return number;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0019.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0019.java
new file mode 100644
index 0000000..2f375a6
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0019.java
@@ -0,0 +1,93 @@
+//给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。 
+//
+// 示例： 
+//
+// 给定一个链表: 1->2->3->4->5, 和 n = 2.
+//
+//当删除了倒数第二个节点后，链表变为 1->2->3->5.
+// 
+//
+// 说明： 
+//
+// 给定的 n 保证是有效的。 
+//
+// 进阶： 
+//
+// 你能尝试使用一趟扫描实现吗？ 
+// Related Topics 链表 双指针 
+// 👍 887 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 19
+ * 删除链表的倒数第N个节点
+ * remove-nth-node-from-end-of-list
+ */
+public class L0019 {
+
+    public static void main(String[] args) {
+        L0019 instance = new L0019();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+        int n = 2;
+        ListNode head = new ListNode(1);
+        ListNode tail = head;
+        for (int i = 2; i < 6; i++) {
+            tail.next = new ListNode(i);
+            tail = tail.next;
+        }
+        head = solution.removeNthFromEnd(head, n);
+        while (head != null) {
+            System.out.print(head.val + ",");
+            head = head.next;
+        }
+    }
+
+    class ListNode {
+        int val;
+        ListNode next;
+        ListNode(int x) { val = x; }
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        // time = 0 ms, 100%
+        ListNode prev = null, point = null, node = head;
+        while (node != null) {
+            if (point == null) {
+                if (n == 1) {
+                    point = head;
+                }
+            } else {
+                prev = point;
+                point = point.next;
+            }
+            node = node.next;
+            n --;
+        }
+        if (prev == null) {
+            return head.next;
+        } else {
+            prev.next = point.next;
+            return head;
+        }
+
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0020.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0020.java
new file mode 100644
index 0000000..601499b
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0020.java
@@ -0,0 +1,112 @@
+//给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。 
+//
+// 有效字符串需满足： 
+//
+// 
+// 左括号必须用相同类型的右括号闭合。 
+// 左括号必须以正确的顺序闭合。 
+// 
+//
+// 注意空字符串可被认为是有效字符串。 
+//
+// 示例 1: 
+//
+// 输入: "()"
+//输出: true
+// 
+//
+// 示例 2: 
+//
+// 输入: "()[]{}"
+//输出: true
+// 
+//
+// 示例 3: 
+//
+// 输入: "(]"
+//输出: false
+// 
+//
+// 示例 4: 
+//
+// 输入: "([)]"
+//输出: false
+// 
+//
+// 示例 5: 
+//
+// 输入: "{[]}"
+//输出: true 
+// Related Topics 栈 字符串 
+// 👍 1684 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+import java.util.Stack;
+
+/**
+ * 20
+ * 有效的括号
+ * valid-parentheses
+ */
+public class L0020 {
+
+    public static void main(String[] args) {
+//        L0020_valid_parentheses instance = new L0020_valid_parentheses();
+//        instance.test();
+        System.out.println('('+0);
+        System.out.println('['+0);
+        System.out.println('{'+0);
+        System.out.println(')'+0);
+        System.out.println(']'+0);
+        System.out.println('}'+0);
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public boolean isValid(String s) {
+        int len = s.length();
+        if (len == 0) {
+            return true;
+        }
+        if (len % 2 == 1) {
+            return false;
+        }
+        Stack<Character> stack = new Stack<>();
+        boolean ret = true;
+        for (int i = 0; i < len; i++) {
+            char c = s.charAt(i);
+            switch (c) {
+                case ')':
+                    if (stack.empty() || stack.pop() != '(') {
+                        ret = false;
+                    }
+                    break;
+                case ']':
+                    if (stack.empty() || stack.pop() != '[') {
+                        ret = false;
+                    }
+                    break;
+                case '}':
+                    if (stack.empty() || stack.pop() != '{') {
+                        ret = false;
+                    }
+                    break;
+                default:
+                    stack.push(c);
+            }
+            if (!ret) {
+                break;
+            }
+        }
+        return ret && stack.empty();
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0021.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0021.java
new file mode 100644
index 0000000..094cbe0
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0021.java
@@ -0,0 +1,78 @@
+//将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 
+//
+// 
+//
+// 示例： 
+//
+// 输入：1->2->4, 1->3->4
+//输出：1->1->2->3->4->4
+// 
+// Related Topics 链表 
+// 👍 1143 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 21
+ * 合并两个有序链表
+ * merge-two-sorted-lists
+ */
+public class L0021 {
+
+    public static void main(String[] args) {
+        L0021 instance = new L0021();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+    class ListNode {
+        int val;
+        ListNode next;
+        ListNode() {}
+        ListNode(int val) { this.val = val; }
+        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+        ListNode list = new ListNode();
+        ListNode node = list;
+        while (true) {
+            if (l1 == null) {
+                node.next = l2;
+                break;
+            }
+            if (l2 == null) {
+                node.next = l1;
+                break;
+            }
+            if (l1.val > l2.val) {
+                node.next = l2;
+                l2 = l2.next;
+            } else {
+                node.next = l1;
+                l1 = l1.next;
+            }
+            node = node.next;
+        }
+        return list.next;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0026.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0026.java
new file mode 100644
index 0000000..5e7a835
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0026.java
@@ -0,0 +1,86 @@
+//给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。 
+//
+// 不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。 
+//
+// 
+//
+// 示例 1: 
+//
+// 给定数组 nums = [1,1,2], 
+//
+//函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。 
+//
+//你不需要考虑数组中超出新长度后面的元素。 
+//
+// 示例 2: 
+//
+// 给定 nums = [0,0,1,1,1,2,2,3,3,4],
+//
+//函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
+//
+//你不需要考虑数组中超出新长度后面的元素。
+// 
+//
+// 
+//
+// 说明: 
+//
+// 为什么返回数值是整数，但输出的答案是数组呢? 
+//
+// 请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。 
+//
+// 你可以想象内部操作如下: 
+//
+// // nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
+//int len = removeDuplicates(nums);
+//
+//// 在函数里修改输入数组对于调用者是可见的。
+//// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
+//for (int i = 0; i < len; i++) {
+//    print(nums[i]);
+//}
+// 
+// Related Topics 数组 双指针 
+// 👍 1527 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 26
+ * 删除排序数组中的重复项
+ * remove-duplicates-from-sorted-array
+ */
+public class L0026 {
+
+    public static void main(String[] args) {
+        L0026 instance = new L0026();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int removeDuplicates(int[] nums) {
+        // time = 1 ms, 98.03%
+        if (nums == null) {
+            return 0;
+        }
+//        if (nums.length < 2) {
+//            return nums.length;
+//        }
+        int point = 0;
+        for (int index = 1; index < nums.length; index++) {
+            if (nums[index] > nums[point]) {
+                nums[++point] = nums[index];
+            }
+        }
+        return point + 1;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0027.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0027.java
new file mode 100644
index 0000000..da28b13
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0027.java
@@ -0,0 +1,94 @@
+//给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。 
+//
+// 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。 
+//
+// 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。 
+//
+// 
+//
+// 示例 1: 
+//
+// 给定 nums = [3,2,2,3], val = 3,
+//
+//函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
+//
+//你不需要考虑数组中超出新长度后面的元素。
+// 
+//
+// 示例 2: 
+//
+// 给定 nums = [0,1,2,2,3,0,4,2], val = 2,
+//
+//函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
+//
+//注意这五个元素可为任意顺序。
+//
+//你不需要考虑数组中超出新长度后面的元素。
+// 
+//
+// 
+//
+// 说明: 
+//
+// 为什么返回数值是整数，但输出的答案是数组呢? 
+//
+// 请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。 
+//
+// 你可以想象内部操作如下: 
+//
+// // nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
+//int len = removeElement(nums, val);
+//
+//// 在函数里修改输入数组对于调用者是可见的。
+//// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
+//for (int i = 0; i < len; i++) {
+//    print(nums[i]);
+//}
+// 
+// Related Topics 数组 双指针 
+// 👍 592 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 27
+ * 移除元素
+ * remove-element
+ */
+public class L0027 {
+
+    public static void main(String[] args) {
+        L0027 instance = new L0027();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int removeElement(int[] nums, int val) {
+        // time = 0 ms, 100%
+        if (nums == null || nums.length == 0) {
+            return 0;
+        }
+        int start = 0;
+        for (int end = nums.length - 1; start <= end; ) {
+            if (nums[start] == val) {
+                if (nums[end] != val) {
+                    nums[start] = nums[end];
+                    start ++;
+                }
+                end --;
+            } else {
+                start ++;
+            }
+        }
+        return start;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0035.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0035.java
new file mode 100644
index 0000000..3b79317
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0035.java
@@ -0,0 +1,69 @@
+//给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。 
+//
+// 你可以假设数组中无重复元素。 
+//
+// 示例 1: 
+//
+// 输入: [1,3,5,6], 5
+//输出: 2
+// 
+//
+// 示例 2: 
+//
+// 输入: [1,3,5,6], 2
+//输出: 1
+// 
+//
+// 示例 3: 
+//
+// 输入: [1,3,5,6], 7
+//输出: 4
+// 
+//
+// 示例 4: 
+//
+// 输入: [1,3,5,6], 0
+//输出: 0
+// 
+// Related Topics 数组 二分查找 
+// 👍 560 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 35
+ * 搜索插入位置
+ * search-insert-position
+ */
+public class L0035 {
+
+    public static void main(String[] args) {
+        L0035 instance = new L0035();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int searchInsert(int[] nums, int target) {
+        int start = 0, end = nums.length - 1, mid = end / 2;
+        while (end >= start) {
+            if (target == nums[mid]) {
+                return mid;
+            } else if (target < nums[mid]) {
+                end = mid - 1;
+            } else {
+                start = mid + 1;
+            }
+            mid = (start + end) / 2;
+        }
+        return end + 1;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0036.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0036.java
new file mode 100644
index 0000000..1132dd2
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0036.java
@@ -0,0 +1,120 @@
+//判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。 
+//
+// 
+// 数字 1-9 在每一行只能出现一次。 
+// 数字 1-9 在每一列只能出现一次。 
+// 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 
+// 
+//
+// 
+//
+// 上图是一个部分填充的有效的数独。 
+//
+// 数独部分空格内已填入了数字，空白格用 '.' 表示。 
+//
+// 示例 1: 
+//
+// 输入:
+//[
+//  ["5","3",".",".","7",".",".",".","."],
+//  ["6",".",".","1","9","5",".",".","."],
+//  [".","9","8",".",".",".",".","6","."],
+//  ["8",".",".",".","6",".",".",".","3"],
+//  ["4",".",".","8",".","3",".",".","1"],
+//  ["7",".",".",".","2",".",".",".","6"],
+//  [".","6",".",".",".",".","2","8","."],
+//  [".",".",".","4","1","9",".",".","5"],
+//  [".",".",".",".","8",".",".","7","9"]
+//]
+//输出: true
+// 
+//
+// 示例 2: 
+//
+// 输入:
+//[
+//  ["8","3",".",".","7",".",".",".","."],
+//  ["6",".",".","1","9","5",".",".","."],
+//  [".","9","8",".",".",".",".","6","."],
+//  ["8",".",".",".","6",".",".",".","3"],
+//  ["4",".",".","8",".","3",".",".","1"],
+//  ["7",".",".",".","2",".",".",".","6"],
+//  [".","6",".",".",".",".","2","8","."],
+//  [".",".",".","4","1","9",".",".","5"],
+//  [".",".",".",".","8",".",".","7","9"]
+//]
+//输出: false
+//解释: 除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。
+//     但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。 
+//
+// 说明: 
+//
+// 
+// 一个有效的数独（部分已被填充）不一定是可解的。 
+// 只需要根据以上规则，验证已经填入的数字是否有效即可。 
+// 给定数独序列只包含数字 1-9 和字符 '.' 。 
+// 给定数独永远是 9x9 形式的。 
+// 
+// Related Topics 哈希表 
+// 👍 376 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+import java.util.HashSet;
+
+/**
+ * 36
+ * 有效的数独
+ * valid-sudoku
+ */
+public class L0036 {
+
+    public static void main(String[] args) {
+        L0036 instance = new L0036();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public boolean isValidSudoku(char[][] board) {
+        HashSet<Character>[] rows = new HashSet[9];
+        HashSet<Character>[] cols = new HashSet[9];
+        HashSet<Character>[][] subs = new HashSet[3][3];
+        for (int row = 0; row < 9; row++) {
+            for (int col = 0; col < 9; col++) {
+                char c = board[row][col];
+                if (c == '.') {
+                    continue;
+                }
+                if (rows[row] == null) {
+                    rows[row] = new HashSet<>();
+                }
+                if (!rows[row].add(c)) {
+                    return false;
+                }
+                if (cols[col] == null) {
+                    cols[col] = new HashSet<>();
+                }
+                if (!cols[col].add(c)) {
+                    return false;
+                }
+                int subrow = row / 3, subcol = col / 3;
+                if (subs[subrow][subcol] == null) {
+                    subs[subrow][subcol] = new HashSet<>();
+                }
+                if (!subs[subrow][subcol].add(c)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0038.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0038.java
new file mode 100644
index 0000000..59d94bd
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0038.java
@@ -0,0 +1,86 @@
+//给定一个正整数 n（1 ≤ n ≤ 30），输出外观数列的第 n 项。 
+//
+// 注意：整数序列中的每一项将表示为一个字符串。 
+//
+// 「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。前五项如下： 
+//
+// 1.     1
+//2.     11
+//3.     21
+//4.     1211
+//5.     111221
+// 
+//
+// 第一项是数字 1 
+//
+// 描述前一项，这个数是 1 即 “一个 1 ”，记作 11 
+//
+// 描述前一项，这个数是 11 即 “两个 1 ” ，记作 21 
+//
+// 描述前一项，这个数是 21 即 “一个 2 一个 1 ” ，记作 1211 
+//
+// 描述前一项，这个数是 1211 即 “一个 1 一个 2 两个 1 ” ，记作 111221 
+//
+// 
+//
+// 示例 1: 
+//
+// 输入: 1
+//输出: "1"
+//解释：这是一个基本样例。 
+//
+// 示例 2: 
+//
+// 输入: 4
+//输出: "1211"
+//解释：当 n = 3 时，序列是 "21"，其中我们有 "2" 和 "1" 两组，"2" 可以读作 "12"，也就是出现频次 = 1 而 值 = 2；类似 
+//"1" 可以读作 "11"。所以答案是 "12" 和 "11" 组合在一起，也就是 "1211"。 
+// Related Topics 字符串 
+// 👍 504 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 38
+ * 外观数列
+ * count-and-say
+ */
+public class L0038 {
+
+    public static void main(String[] args) {
+        L0038 instance = new L0038();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public String countAndSay(int n) {
+        if (n == 1) {
+            return "1";
+        }
+        String str = countAndSay(n - 1);
+        StringBuilder ret = new StringBuilder();
+        int count = 1;
+        char say = str.charAt(0);
+        for (int index = 1; index < str.length(); index++) {
+            char c = str.charAt(index);
+            if (c != say) {
+                ret.append(count).append(say);
+                count = 1;
+                say = c;
+            } else {
+                count ++;
+            }
+        }
+        ret.append(count).append(say);
+        return ret.toString();
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0058.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0058.java
new file mode 100644
index 0000000..c8e9ba0
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0058.java
@@ -0,0 +1,54 @@
+//给定一个仅包含大小写字母和空格 ' ' 的字符串 s，返回其最后一个单词的长度。如果字符串从左向右滚动显示，那么最后一个单词就是最后出现的单词。 
+//
+// 如果不存在最后一个单词，请返回 0 。 
+//
+// 说明：一个单词是指仅由字母组成、不包含任何空格字符的 最大子字符串。 
+//
+// 
+//
+// 示例: 
+//
+// 输入: "Hello World"
+//输出: 5
+// 
+// Related Topics 字符串 
+// 👍 225 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 58
+ * 最后一个单词的长度
+ * length-of-last-word
+ */
+public class L0058 {
+
+    public static void main(String[] args) {
+        L0058 instance = new L0058();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int lengthOfLastWord(String s) {
+        if (s==null || s.isBlank()) {
+            return 0;
+        }
+        for (int i = s.length()-1; i >= 0 ; i--) {
+            if (s.charAt(i) != ' ') {
+                s = s.substring(0, i+1);
+                break;
+            }
+        }
+        int index = s.lastIndexOf(' ');
+        return s.length()-1-index;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0066.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0066.java
new file mode 100644
index 0000000..19337e5
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0066.java
@@ -0,0 +1,61 @@
+//给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。 
+//
+// 最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。 
+//
+// 你可以假设除了整数 0 之外，这个整数不会以零开头。 
+//
+// 示例 1: 
+//
+// 输入: [1,2,3]
+//输出: [1,2,4]
+//解释: 输入数组表示数字 123。
+// 
+//
+// 示例 2: 
+//
+// 输入: [4,3,2,1]
+//输出: [4,3,2,2]
+//解释: 输入数组表示数字 4321。
+// 
+// Related Topics 数组 
+// 👍 505 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 66
+ * 加一
+ * plus-one
+ */
+public class L0066 {
+
+    public static void main(String[] args) {
+        L0066 instance = new L0066();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int[] plusOne(int[] digits) {
+        int num = 1;
+        for (int i = digits.length - 1; i >= 0 ; i--) {
+            int sum = digits[i] + num;
+            if (sum < 10) {
+                digits[i] = sum;
+                return digits;
+            }
+            digits[i] = 0;
+        }
+        int[] ret = new int[digits.length + 1];
+        ret[0] = 1;
+        return ret;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0069.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0069.java
new file mode 100644
index 0000000..fa9fbdb
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0069.java
@@ -0,0 +1,69 @@
+//实现 int sqrt(int x) 函数。 
+//
+// 计算并返回 x 的平方根，其中 x 是非负整数。 
+//
+// 由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。 
+//
+// 示例 1: 
+//
+// 输入: 4
+//输出: 2
+// 
+//
+// 示例 2: 
+//
+// 输入: 8
+//输出: 2
+//说明: 8 的平方根是 2.82842..., 
+//     由于返回类型是整数，小数部分将被舍去。
+// 
+// Related Topics 数学 二分查找 
+// 👍 452 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 69
+ * x 的平方根
+ * sqrtx
+ */
+public class L0069 {
+
+    public static void main(String[] args) {
+        L0069 instance = new L0069();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int mySqrt(int x) {
+        if (x == 0) {
+            return 0;
+        }
+        if (x < 4) {
+            return 1;
+        }
+        int start = 1, mid = x / 2, end = x;
+        while (start < mid) {
+            long ret = (long)mid * mid;
+            if (ret == x) {
+                break;
+            }
+            if (ret > x) {
+                end = mid;
+            } else {
+                start = mid;
+            }
+            mid = (start + end) / 2;
+        }
+        return mid;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0070.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0070.java
new file mode 100644
index 0000000..5698164
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0070.java
@@ -0,0 +1,65 @@
+//假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 
+//
+// 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？ 
+//
+// 注意：给定 n 是一个正整数。 
+//
+// 示例 1： 
+//
+// 输入： 2
+//输出： 2
+//解释： 有两种方法可以爬到楼顶。
+//1.  1 阶 + 1 阶
+//2.  2 阶 
+//
+// 示例 2： 
+//
+// 输入： 3
+//输出： 3
+//解释： 有三种方法可以爬到楼顶。
+//1.  1 阶 + 1 阶 + 1 阶
+//2.  1 阶 + 2 阶
+//3.  2 阶 + 1 阶
+// 
+// Related Topics 动态规划 
+// 👍 1149 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 70
+ * 爬楼梯
+ * climbing-stairs
+ */
+public class L0070 {
+
+    public static void main(String[] args) {
+        L0070 instance = new L0070();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int climbStairs(int n) {
+        if (n == 1) {
+            return 1;
+        }
+        if (n == 2) {
+            return 2;
+        }
+        int pp = 1, p = 2;
+        for (int i = 3; i <= n; i++) {
+            p += pp;
+            pp = p- pp;
+        }
+        return p;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0083.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0083.java
new file mode 100644
index 0000000..001db64
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0083.java
@@ -0,0 +1,68 @@
+//给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。 
+//
+// 示例 1: 
+//
+// 输入: 1->1->2
+//输出: 1->2
+// 
+//
+// 示例 2: 
+//
+// 输入: 1->1->2->3->3
+//输出: 1->2->3 
+// Related Topics 链表 
+// 👍 352 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 83
+ * 删除排序链表中的重复元素
+ * remove-duplicates-from-sorted-list
+ */
+public class L0083 {
+
+    public static void main(String[] args) {
+        L0083 instance = new L0083();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+    class ListNode {
+        int val;
+        ListNode next;
+        ListNode(int x) { val = x; }
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode deleteDuplicates(ListNode head) {
+        if (head != null) {
+            ListNode end = head, point = head.next;
+            while (point != null) {
+                if (end.val != point.val) {
+                    end.next = point;
+                    end = end.next;
+                }
+                point = point.next;
+            }
+            end.next = null;
+        }
+        return head;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0088.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0088.java
new file mode 100644
index 0000000..64fdf55
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0088.java
@@ -0,0 +1,59 @@
+//给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。 
+//
+// 
+//
+// 说明: 
+//
+// 
+// 初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。 
+// 你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。 
+// 
+//
+// 
+//
+// 示例: 
+//
+// 输入:
+//nums1 = [1,2,3,0,0,0], m = 3
+//nums2 = [2,5,6],       n = 3
+//
+//输出: [1,2,2,3,5,6] 
+// Related Topics 数组 双指针 
+// 👍 571 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 88
+ * 合并两个有序数组
+ * merge-sorted-array
+ */
+public class L0088 {
+
+    public static void main(String[] args) {
+        L0088 instance = new L0088();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public void merge(int[] nums1, int m, int[] nums2, int n) {
+        for (int i = m+n-1; n > 0 ; i--) {
+            if (m > 0 && nums1[m-1] > nums2[n-1]) {
+                nums1[i] = nums1[m-1];
+                m--;
+            } else {
+                nums1[i] = nums2[n-1];
+                n--;
+            }
+        }
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0118.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0118.java
new file mode 100644
index 0000000..cd9d3cf
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0118.java
@@ -0,0 +1,64 @@
+//给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。 
+//
+// 
+//
+// 在杨辉三角中，每个数是它左上方和右上方的数的和。 
+//
+// 示例: 
+//
+// 输入: 5
+//输出:
+//[
+//     [1],
+//    [1,1],
+//   [1,2,1],
+//  [1,3,3,1],
+// [1,4,6,4,1]
+//] 
+// Related Topics 数组 
+// 👍 331 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 118
+ * 杨辉三角
+ * pascals-triangle
+ */
+public class L0118 {
+
+    public static void main(String[] args) {
+        L0118 instance = new L0118();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public List<List<Integer>> generate(int numRows) {
+        List<List<Integer>> list = new ArrayList<>(numRows);
+        for (int row = 0; row < numRows; row++) {
+            List<Integer> rowList = new ArrayList<>(row + 1);
+            list.add(rowList);
+            List<Integer> prevList = row == 0 ? null : list.get(row - 1);
+            for (int i = 0; i <= row; i++) {
+                if (i==0 || i==row) {
+                    rowList.add(1);
+                } else {
+                    rowList.add(prevList.get(i-1) + prevList.get(i));
+                }
+            }
+        }
+        return list;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0119.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0119.java
new file mode 100644
index 0000000..e3b5d4b
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0119.java
@@ -0,0 +1,56 @@
+//给定一个非负索引 k，其中 k ≤ 33，返回杨辉三角的第 k 行。 
+//
+// 
+//
+// 在杨辉三角中，每个数是它左上方和右上方的数的和。 
+//
+// 示例: 
+//
+// 输入: 3
+//输出: [1,3,3,1]
+// 
+//
+// 进阶： 
+//
+// 你可以优化你的算法到 O(k) 空间复杂度吗？ 
+// Related Topics 数组 
+// 👍 164 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 119
+ * 杨辉三角 II
+ * pascals-triangle-ii
+ */
+public class L0119 {
+
+    public static void main(String[] args) {
+        L0119 instance = new L0119();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public List<Integer> getRow(int rowIndex) {
+        List<Integer> list = new ArrayList<>(rowIndex+1);
+        for (int row = 0; row <= rowIndex; row++) {
+            list.add(row, 1);
+            for (int index = row-1; index > 0 ; index--) {
+                list.set(index, list.get(index) + list.get(index-1));
+            }
+        }
+        return list;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0125.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0125.java
new file mode 100644
index 0000000..8b78463
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0125.java
@@ -0,0 +1,67 @@
+//给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。 
+//
+// 说明：本题中，我们将空字符串定义为有效的回文串。 
+//
+// 示例 1: 
+//
+// 输入: "A man, a plan, a canal: Panama"
+//输出: true
+// 
+//
+// 示例 2: 
+//
+// 输入: "race a car"
+//输出: false
+// 
+// Related Topics 双指针 字符串 
+// 👍 254 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 125
+ * 验证回文串
+ * valid-palindrome
+ */
+public class L0125 {
+
+    public static void main(String[] args) {
+        L0125 instance = new L0125();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public boolean isPalindrome(String s) {
+        if (s==null || s.isBlank()) {
+            return true;
+        }
+        s = s.toLowerCase();
+        for (int left = 0, right = s.length()-1; left < right; ) {
+            char leftChar = s.charAt(left), rightChar = s.charAt(right);
+            if (leftChar >= 'a' && leftChar <= 'z' || leftChar >= '0' && leftChar <= '9') {
+                if (rightChar >= 'a' && rightChar <= 'z' || rightChar >= '0' && rightChar <= '9') {
+                    if (leftChar == rightChar) {
+                        left ++;
+                        right --;
+                    } else {
+                        return false;
+                    }
+                } else {
+                    right --;
+                }
+            } else {
+                left ++;
+            }
+        }
+        return true;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0155.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0155.java
new file mode 100644
index 0000000..d64f503
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0155.java
@@ -0,0 +1,109 @@
+//设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。 
+//
+// 
+// push(x) —— 将元素 x 推入栈中。 
+// pop() —— 删除栈顶的元素。 
+// top() —— 获取栈顶元素。 
+// getMin() —— 检索栈中的最小元素。 
+// 
+//
+// 
+//
+// 示例: 
+//
+// 输入：
+//["MinStack","push","push","push","getMin","pop","top","getMin"]
+//[[],[-2],[0],[-3],[],[],[],[]]
+//
+//输出：
+//[null,null,null,null,-3,null,0,-2]
+//
+//解释：
+//MinStack minStack = new MinStack();
+//minStack.push(-2);
+//minStack.push(0);
+//minStack.push(-3);
+//minStack.getMin();   --> 返回 -3.
+//minStack.pop();
+//minStack.top();      --> 返回 0.
+//minStack.getMin();   --> 返回 -2.
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// pop、top 和 getMin 操作总是在 非空栈 上调用。 
+// 
+// Related Topics 栈 设计 
+// 👍 616 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 155
+ * 最小栈
+ * min-stack
+ */
+public class L0155 {
+
+    public static void main(String[] args) {
+        L0155 instance = new L0155();
+        instance.test();
+    }
+
+    void test() {
+        // Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class MinStack {
+
+        int val;
+        MinStack next;
+        MinStack min;
+
+    /** initialize your data structure here. */
+    public MinStack() {
+
+    }
+    
+    public void push(int x) {
+        MinStack stack = new MinStack();
+        stack.val = x;
+        if (next==null) {
+            stack.min = stack;
+            next = stack;
+        } else {
+            stack.min = next.min.val > x ? stack : next.min;
+            stack.next = next;
+            next = stack;
+        }
+    }
+    
+    public void pop() {
+        next = next.next;
+    }
+    
+    public int top() {
+        return next.val;
+    }
+    
+    public int getMin() {
+        return next.min.val;
+    }
+}
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * MinStack obj = new MinStack();
+ * obj.push(x);
+ * obj.pop();
+ * int param_3 = obj.top();
+ * int param_4 = obj.getMin();
+ */
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0171.java b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0171.java
new file mode 100644
index 0000000..b4682ed
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/leetcode/editor/cn/L0171.java
@@ -0,0 +1,69 @@
+//给定一个Excel表格中的列名称，返回其相应的列序号。 
+//
+// 例如， 
+//
+//     A -> 1
+//    B -> 2
+//    C -> 3
+//    ...
+//    Z -> 26
+//    AA -> 27
+//    AB -> 28 
+//    ...
+// 
+//
+// 示例 1: 
+//
+// 输入: "A"
+//输出: 1
+// 
+//
+// 示例 2: 
+//
+// 输入: "AB"
+//输出: 28
+// 
+//
+// 示例 3: 
+//
+// 输入: "ZY"
+//输出: 701 
+//
+// 致谢： 
+//特别感谢 @ts 添加此问题并创建所有测试用例。 
+// Related Topics 数学 
+// 👍 162 👎 0
+
+package com.starriddle.starter.java.leetcode.editor.cn;
+
+/**
+ * 171
+ * Excel表列序号
+ * excel-sheet-column-number
+ */
+public class L0171 {
+
+    public static void main(String[] args) {
+        L0171 instance = new L0171();
+        instance.test();
+    }
+
+    void test() {
+        Solution solution = new Solution();
+        // TODO
+    }
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int titleToNumber(String s) {
+        int number = 0;
+        for (int index = 0; index < s.length(); index++) {
+            char c = s.charAt(index);
+            number = number * 26 + c + 1 - 'A';
+        }
+        return number;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
diff --git a/src/main/java/com/starriddle/starter/java/util/RegexUtil.java b/src/main/java/com/starriddle/starter/java/util/RegexUtil.java
new file mode 100644
index 0000000..6f07d12
--- /dev/null
+++ b/src/main/java/com/starriddle/starter/java/util/RegexUtil.java
@@ -0,0 +1,15 @@
+package com.starriddle.starter.java.util;
+
+/**
+ * description
+ *
+ * @author CYL
+ * @date 2019-08-01
+ */
+public class RegexUtil {
+    public static void main(String[] args) {
+        String regex = ".+[0-9]{17}[0-9Xx]";
+        String name = "A33221119990112668X";
+        System.out.println(name.matches(regex));
+    }
+}