diff --git a/.gitignore b/.gitignore
index e525b8f0e06b6ea2e7f51e12c69c0001861ef761..79f908f0afe56321322a26c10ea1c122948286ad 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 .DS_Store
 */.DS_Store
+/kickstart/*
 test.java
diff --git a/code/lc162.java b/code/lc162.java
new file mode 100644
index 0000000000000000000000000000000000000000..66389e641aad60ca791189a98cea546e690757e6
--- /dev/null
+++ b/code/lc162.java
@@ -0,0 +1,48 @@
+package code;
+/*
+ * 162. Find Peak Element
+ * 题意：找出数组中任意一个山顶点，时间复杂度O(lg(n))，山顶点指该数左右两边都的数都小于他
+ * 难度：Medium
+ * 分类：Array, Binary Search
+ * 思路：二分查找，想好左右两边递归判断。只有nums[mid]<nums[mid+1]，说名右半边就存在峰值
+ * Tips：
+ */
+public class lc162 {
+    public int findPeakElement(int[] nums) {
+        int[] nums2 = new int[nums.length+2];   //左右加了个最小值
+        for (int i = 0; i < nums.length ; i++) {
+            nums2[i+1] = nums[i];
+        }
+        nums2[0] = Integer.MIN_VALUE;
+        nums2[nums2.length-1] = Integer.MIN_VALUE;
+        return helper(nums2, 1, nums2.length-2)-1;
+    }
+    public int helper(int[] nums, int left, int right){
+        System.out.println(nums.length);
+        while(left<=right){
+            int mid = (left+right)/2;
+            if(nums[mid]>nums[mid+1]&&nums[mid]>nums[mid-1]) return mid;
+            if(nums[mid]<nums[mid+1]){
+                left = mid+1;
+            }else{
+                right = mid-1;
+            }
+        }
+        return left;
+    }
+
+    public int findPeakElement2(int[] nums) {   //第二种方法不用左右加个边界
+        return helper2(nums, 0, nums.length-1);
+    }
+    public int helper2(int[] nums, int left, int right){
+        while(left<right){  //这没有==
+            int mid = (left+right)/2;
+            if(nums[mid]<nums[mid+1]){
+                left = mid+1;
+            }else{
+                right = mid;      //这没有-1
+            }
+        }
+        return left;
+    }
+}
diff --git a/code/lc166.java b/code/lc166.java
new file mode 100644
index 0000000000000000000000000000000000000000..aeac247202a6d69b85da4e524dc4510b060f8ab8
--- /dev/null
+++ b/code/lc166.java
@@ -0,0 +1,39 @@
+package code;
+
+import java.util.HashMap;
+
+/*
+ * 166. Fraction to Recurring Decimal
+ * 题意：实现除法，循环小数部分用（）括起来
+ * 难度：Medium
+ * 分类：Hash Table, Math
+ * 思路：首先计算整数部分，然后加上小数点，再计算小数部分
+ *      用 Hash Table 记录之前的余数，余数相同表示小数点开始循环。
+ *      注意符号和溢出的情况
+ * Tips：看似简单的题，并不好写
+ */
+public class lc166 {
+    public String fractionToDecimal(int numerator, int denominator) {
+        StringBuilder sb = new StringBuilder();
+        if( (numerator>0&&denominator<0) || (numerator<0&&denominator>0)) sb.append("-");   //符号
+        long num = Math.abs((long)numerator);     //用long防止溢出
+        long den = Math.abs((long)denominator);
+        sb.append(num/den);   //整数部分
+
+        HashMap<Long, Integer> hm = new HashMap();    //key存储余数，余数>0 <9， value存储index，用来加(
+        long n = num%den;
+        if(n!=0) sb.append(".");
+        while( n!=0 && !hm.containsKey(n)){
+            hm.put(n, sb.length());
+            n = n*10;
+            sb.append(n/den);
+            n = n%den;
+        }
+        if(hm.containsKey(n)){
+            int index = hm.get(n);
+            sb.insert(index, "(");
+            sb.append(")");
+        }
+        return sb.toString();
+    }
+}
diff --git a/code/lc179.java b/code/lc179.java
new file mode 100644
index 0000000000000000000000000000000000000000..abde2633cf07ec70f1e438b90326f3d238f8c301
--- /dev/null
+++ b/code/lc179.java
@@ -0,0 +1,35 @@
+package code;
+/*
+ * 179. Largest Number
+ * 题意：给一个由数字组成的数组，返回排列组合成的最大数
+ * 难度：Medium
+ * 分类：Sort
+ * 思路：两个数字，i+j 与 j+i 比较，排序。
+ *      学会实现Comparator接口
+ * Tips：要先转换成string再实现Comparator接口，直接比较字符串，比较数字会报错。。。
+ */
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class lc179 {
+    public String largestNumber(int[] nums) {
+        String[] strs = new String[nums.length];    //先转换成string再比较
+        for (int i = 0; i < strs.length ; i++) {
+            strs[i] = String.valueOf(nums[i]);
+        }
+        Arrays.sort(strs, new Comparator<String>() {    // Comparator接口
+            @Override
+            public int compare(String i, String j) {
+                String s1 = i+j;    // i+j 与 j+i 比较
+                String s2 = j+i;
+                return s2.compareTo(s1);
+            }
+        });
+        if(strs[0].equals("0")) return "0";     //防止"000"的情况
+        String res = "";
+        for (String str:strs) {
+            res+=str;
+        }
+        return res;
+    }
+}
diff --git a/code/lc212.java b/code/lc212.java
new file mode 100644
index 0000000000000000000000000000000000000000..c100451fcbae358ee2924a5188aadea54f439312
--- /dev/null
+++ b/code/lc212.java
@@ -0,0 +1,43 @@
+package code;
+/*
+ * 212. Word Search II
+ * 题意：找出字符数组中路径可以拼出的字符串
+ * 难度：Hard
+ * 分类：Backtracking, Trie
+ * 思路：暴力搜索回溯法就可以AC
+ *      更好的方法是借助字典树数据结构进行剪枝，减少重复的搜索路径
+ *      https://leetcode.com/problems/word-search-ii/discuss/59780/Java-15ms-Easiest-Solution-(100.00)
+ * Tips：
+ */
+import java.util.ArrayList;
+import java.util.List;
+
+public class lc212 {
+    public List<String> findWords(char[][] board, String[] words) {
+        //暴力搜索
+        List<String> res = new ArrayList<>();
+        for (int i = 0; i < board.length ; i++) {
+            for (int j = 0; j < board[0].length ; j++) {
+                for (int k = 0; k < words.length ; k++) {
+                    char[] str = words[k].toCharArray();
+                    if(dfs(board, i, j, str, 0)&&!res.contains(words[k])) res.add(words[k]);  //记得去重
+                }
+            }
+        }
+        return res;
+    }
+    public boolean dfs(char[][] board, int i, int j, char[] str, int index){
+        if(i<0||j<0||i>=board.length||j>=board[0].length||index>=str.length) return false;
+        if(board[i][j]==str[index]){
+            if(index==str.length-1) return true;
+            board[i][j] = '0';
+            boolean res = dfs(board, i+1, j, str, index+1)||
+                    dfs(board, i-1, j, str, index+1)||
+                    dfs(board, i, j+1, str, index+1)||
+                    dfs(board, i, j-1, str, index+1);   //用res记录结果，重置字符以后再返回
+            board[i][j] = str[index];   //记得回溯后重置为原来的字符
+            return res;
+        }
+        return false;
+    }
+}