custom code demo

Author: shuzijun

README.md

@@ -1 +1,19 @@
-# leetcode-question
+# leetcode-question
+  [leetcode-editor](https://github.com/shuzijun/leetcode-question) custom code demo    
+## leetcode-editor config  
+  CodeFileName:
+  ```java
+  $!velocityTool.camelCaseName(${question.titleSlug})
+  ```
+  TemplateConstant:
+  ```java
+    ${question.content}
+    
+    package com.shuzijun.leetcode.editor.en;
+    public class $!velocityTool.camelCaseName(${question.titleSlug}){
+        public static void main(String[] args) {
+             Solution solution = new $!velocityTool.camelCaseName(${question.titleSlug})().new Solution();
+        }
+        ${question.code}
+    }
+  ```

pom.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.shuzijun</groupId>
+    <artifactId>leetcode-question</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+
+</project>

src/main/java/com/shuzijun/leetcode/HelloWorld.java

@@ -0,0 +1,15 @@
+package com.shuzijun.leetcode;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: shuzijun
+ * Date: 2018-11-22
+ * Time: 20:52
+ * To change this template use File | Settings | File Templates.
+ */
+public class HelloWorld {
+
+    public static void main(String[] args) {
+        System.out.println("hello world");
+    }
+}

src/main/java/com/shuzijun/leetcode/ListNode.java

@@ -0,0 +1,22 @@
+package com.shuzijun.leetcode;
+
+/**
+
+ */
+public class ListNode {
+    public int val;
+    public ListNode next;
+
+    public ListNode(int x) {
+        val = x;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder().append(val);
+        if (next != null) {
+            sb.append("->").append(next);
+        }
+        return sb.toString();
+    }
+}

src/main/java/com/shuzijun/leetcode/editor/en/AddTwoNumbers.java

@@ -0,0 +1,68 @@
+//You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list. 
+//
+// You may assume the two numbers do not contain any leading zero, except the number 0 itself. 
+//
+// Example: 
+//
+// 
+//Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
+//Output: 7 -> 0 -> 8
+//Explanation: 342 + 465 = 807.
+// 
+//
+
+package com.shuzijun.leetcode.editor.en;
+
+import com.shuzijun.leetcode.ListNode;
+
+public class AddTwoNumbers {
+    public static void main(String[] args) {
+        Solution solution = new AddTwoNumbers().new Solution();
+    }
+
+
+//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) {
+            int carrying = 0;
+            ListNode returnListNode = null;
+            ListNode thisListNode = null;
+            while (l1 != null || l2 != null || carrying != 0) {
+                int val1 = 0;
+                int val2 = 0;
+                if (l1 != null) {
+                    val1 = l1.val;
+                    l1 = l1.next;
+                }
+                if (l2 != null) {
+                    val2 = l2.val;
+                    l2 = l2.next;
+                }
+                int val = val1 + val2 + carrying;
+                if (returnListNode == null) {
+                    returnListNode = new ListNode(val % 10);
+                    thisListNode = returnListNode;
+                } else {
+                    ListNode nextListNode = new ListNode(val % 10);
+                    thisListNode.next = nextListNode;
+                    thisListNode = nextListNode;
+
+                }
+                carrying = val / 10;
+
+            }
+            return returnListNode;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/com/shuzijun/leetcode/editor/en/ContainerWithMostWater.java

@@ -0,0 +1,51 @@
+//Given n non-negative integers a1, a2, ..., an , where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water. 
+//
+// Note: You may not slant the container and n is at least 2. 
+//
+// 
+//
+// 
+//
+// The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49. 
+//
+// 
+//
+// Example: 
+//
+// 
+//Input: [1,8,6,2,5,4,8,3,7]
+//Output: 49 
+//
+
+package com.shuzijun.leetcode.editor.en;
+
+public class ContainerWithMostWater {
+    public static void main(String[] args) {
+        Solution solution = new ContainerWithMostWater().new Solution();
+        int[] height = {1, 8, 6, 2, 5, 4, 8, 3, 7};
+        int max = solution.maxArea(height);
+        System.out.println(max);
+    }
+
+
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int maxArea(int[] height) {
+            int max = 0;
+            int l = 0;
+            int r = height.length - 1;
+            while (l < r) {
+                int h = Math.min(height[l], height[r]);
+                max = Math.max(max, (r - l) * h);
+                if (height[l] < height[r]) {
+                    l++;
+                } else {
+                    r--;
+                }
+            }
+            return max;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/com/shuzijun/leetcode/editor/en/GenerateParentheses.java

@@ -0,0 +1,53 @@
+//
+//Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
+// 
+//
+// 
+//For example, given n = 3, a solution set is:
+// 
+// 
+//[
+//  "((()))",
+//  "(()())",
+//  "(())()",
+//  "()(())",
+//  "()()()"
+//]
+//
+
+package com.shuzijun.leetcode.editor.en;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GenerateParentheses {
+    public static void main(String[] args) {
+        Solution solution = new GenerateParentheses().new Solution();
+        System.out.print(solution.generateParenthesis(3));
+    }
+
+
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public List<String> generateParenthesis(int n) {
+            List<String> ans = new ArrayList();
+            backtrack(ans, "", 0, 0, n);
+            return ans;
+        }
+
+        public void backtrack(List<String> ans, String cur, int open, int close, int max) {
+            if (cur.length() == max * 2) {
+                ans.add(cur);
+                return;
+            }
+
+            if (open < max)
+                backtrack(ans, cur + "(", open + 1, close, max);
+            if (close < open)
+                backtrack(ans, cur + ")", open, close + 1, max);
+        }
+
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/com/shuzijun/leetcode/editor/en/PalindromeNumber.java

@@ -0,0 +1,64 @@
+//Determine whether an integer is a palindrome. An integer is a palindrome when it reads the same backward as forward. 
+//
+// Example 1: 
+//
+// 
+//Input: 121
+//Output: true
+// 
+//
+// Example 2: 
+//
+// 
+//Input: -121
+//Output: false
+//Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.
+// 
+//
+// Example 3: 
+//
+// 
+//Input: 10
+//Output: false
+//Explanation: Reads 01 from right to left. Therefore it is not a palindrome.
+// 
+//
+// Follow up: 
+//
+// Coud you solve it without converting the integer to a string? 
+//
+
+package com.shuzijun.leetcode.editor.en;
+
+public class PalindromeNumber {
+    public static void main(String[] args) {
+        Solution solution = new PalindromeNumber().new Solution();
+        System.out.println(solution.isPalindrome(10));
+    }
+
+
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public boolean isPalindrome(int x) {
+            if (x < 0 || (x % 10 == 0 && x != 0)) {
+                return false;
+            } else if (x < 10) {
+                return true;
+            }
+            int i = 0;
+            while (true) {
+                i = i * 10 + x % 10;
+                x = x / 10;
+                if (i == x) {
+                    return true;
+                } else if (i > x && (i % x < 10 && i / 10 == x)) {
+                    return true;
+                } else if (i > x) {
+                    return false;
+                }
+            }
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/com/shuzijun/leetcode/editor/en/ReverseInteger.java

@@ -0,0 +1,52 @@
+//Given a 32-bit signed integer, reverse digits of an integer. 
+//
+// Example 1: 
+//
+// 
+//Input: 123
+//Output: 321
+// 
+//
+// Example 2: 
+//
+// 
+//Input: -123
+//Output: -321
+// 
+//
+// Example 3: 
+//
+// 
+//Input: 120
+//Output: 21
+// 
+//
+// Note: 
+//Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−231, 231 − 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows. 
+//
+
+package com.shuzijun.leetcode.editor.en;
+
+public class ReverseInteger {
+    public static void main(String[] args) {
+        Solution solution = new ReverseInteger().new Solution();
+    }
+
+
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int reverse(int x) {
+            int rev = 0;
+            while (x != 0) {
+                int pop = x % 10;
+                x /= 10;
+                if (rev > Integer.MAX_VALUE / 10 || (rev == Integer.MAX_VALUE / 10 && pop > 7)) return 0;
+                if (rev < Integer.MIN_VALUE / 10 || (rev == Integer.MIN_VALUE / 10 && pop < -8)) return 0;
+                rev = rev * 10 + pop;
+            }
+            return rev;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}