Merge branch 'master' of https://github.com/SDE603/LeetCode-Solution

Author: taryn2016

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 SDE603
+Copyright (c) 2018 RichCodersAndMe
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

MAINTENANCE_NOTES.md

@@ -12,7 +12,7 @@
 - [其他问题](#其他问题)
 
 ## 本仓库的起源
-为避免误解，以下称[SDE603/LeetCode-Solution][lcs]为**本仓库**, 被介绍的仓库称为**此仓库**。
+为避免误解，以下称[RichCodersAndMe/LeetCode-Solution][lcs]为**本仓库**, 被介绍的仓库称为**此仓库**。
 ### 来源1: [@Blankj][blankj]的[awsome-java-leetcode][ajl]
 **此仓库**由[@Blankj][blankj]于2017年4月18日创建, 不定期更新优质**Java**代码和题解，颇受好评，至今已有star数**3521**颗(star数量以仓库原址为准)。截止**本仓库**建立为止, **此仓库**已累计拥有**63**题已AC的Java代码。
 ### 来源2: [@Wang-YS][wys]的[leetcode][lc]
@@ -72,7 +72,7 @@ commit信息模板: ``feat: add the solution of `Two Sum`(001) with Java``
 [ajl]: https://github.com/Blankj/awesome-java-leetcode
 [wys]: https://github.com/Wang-YS
 [lc]: https://github.com/Wang-YS/leetcode
-[lcs]: https://github.com/SDE603/LeetCode-Solution
+[lcs]: https://github.com/RichCodersAndMe/LeetCode-Solution
 [old-lcs]: https://github.com/CodeAntStudio/LeetCode-Solution
 [wangxin]: https://github.com/relish-wang
 [Mukyu]: https://github.com/Mukyu

README.md

@@ -41,11 +41,11 @@
 | [038][038-question] | [Count and Say][038-tips]                                    | [✅][038-java] |              | [✅][038-kotlin] |
 | [053][053-question] | [Maximum Subarray][053-tips]                                 | [✅][053-java] |              | [✅][053-kotlin] |
 | [058][058-question] | [Length of Last Word][058-tips]                              | [✅][058-java] |              | [✅][058-kotlin] |
-| [066][066-question] | [Plus One][066-tips]                                         | [✅][066-java] |              |                  |
-| [067][067-question] | [Add Binary][067-tips]                                       | [✅][067-java] |              |                  |
-| [069][069-question] | [Sqrt(x)][069-tips]                                          | [✅][069-java] |              |                  |
-| [070][070-question] | [Climbing Stairs][070-tips]                                  | [✅][070-java] |              |                  |
-| [083][083-question] | [Remove Duplicates from Sorted List][083-tips]               | [✅][083-java] |              |                  |
+| [066][066-question] | [Plus One][066-tips]                                         | [✅][066-java] |              | [✅][066-kotlin] |
+| [067][067-question] | [Add Binary][067-tips]                                       | [✅][067-java] |              | [✅][067-kotlin] |
+| [069][069-question] | [Sqrt(x)][069-tips]                                          | [✅][069-java] |              | [✅][069-kotlin] |
+| [070][070-question] | [Climbing Stairs][070-tips]                                  | [✅][070-java] |              | [✅][070-kotlin] |
+| [083][083-question] | [Remove Duplicates from Sorted List][083-tips]               | [✅][083-java] |              | [✅][083-kotlin] |
 | [088][088-question] | [Merge Sorted Array][088-tips]                               | [✅][088-java] |              |                  |
 | [100][100-question] | [Same Tree][100-tips]                                        | [✅][100-java] |              |                  |
 | [101][101-question] | [Symmetric Tree][101-tips]                                   | [✅][101-java] |              |                  |
@@ -69,10 +69,10 @@
 | [661][661-question] | [Image Smoother][661-tips]                                   | [✅][661-java] | [✅][661-js] |                  |
 | [665][665-question] | [Non-decreasing Array][665-tips]                             | [✅][665-java] | [✅][665-js] |                  |
 | [669][669-question] | [Trim a Binary Search Tree][669-tips]                        | [✅][669-java] | [✅][669-js] |                  |
-| [671][671-question] | [Second Minimum Node In a Binary Tree][671-tips]             |                | [✅][671-js] |                  |
-| [674][674-question] | [Longest Continuous Increasing Subsequence][674-tips]        |                | [✅][674-js] |                  |
-| [680][680-question] | [Valid Palindrome II][680-tips]                              |                | [✅][680-js] |                  |
-| [682][682-question] | [Baseball Game][682-tips]                                    |                | [✅][682-js] |                  |
+| [671][671-question] | [Second Minimum Node In a Binary Tree][671-tips]             | [✅][671-java] | [✅][671-js] |                  |
+| [674][674-question] | [Longest Continuous Increasing Subsequence][674-tips]        | [✅][674-java] | [✅][674-js] |                  |
+| [680][680-question] | [Valid Palindrome II][680-tips]                              | [✅][680-java] | [✅][680-js] |                  |
+| [682][682-question] | [Baseball Game][682-tips]                                    | [✅][682-java] | [✅][682-js] |                  |
 | [686][686-question] | [Repeated String Match][686-tips]                            |                | [✅][686-js] |                  |
 | [687][687-question] | [Longest Univalue Path][687-tips]                            |                | [✅][687-js] |                  |
 | [693][693-question] | [Binary Number with Alternating Bits][693-tips]              |                | [✅][693-js] |                  |
@@ -465,6 +465,10 @@
 [661-java]: ./src/_661/Solution.java
 [665-java]: ./src/_665/Solution.java
 [669-java]: ./src/_669/Solution.java
+[671-java]: ./src/_671/Solution.java
+[674-java]: ./src/_674/Solution.java
+[680-java]: ./src/_680/Solution.java
+[682-java]: ./src/_682/Solution.java
 [728-java]: ./src/_728/Solution.java
 [771-java]: ./src/_771/Solution.java
 [804-java]: ./src/_804/Solution.java
@@ -484,4 +488,9 @@
 [038-kotlin]: ./src/_038/kotlin/Solution.kt
 [053-kotlin]: ./src/_053/kotlin/Solution.kt
 [058-kotlin]: ./src/_058/kotlin/Solution.kt
+[066-kotlin]: ./src/_066/kotlin/Solution.kt
+[067-kotlin]: ./src/_067/kotlin/Solution.kt
+[069-kotlin]: ./src/_069/kotlin/Solution.kt
+[070-kotlin]: ./src/_070/kotlin/Solution.kt
+[083-kotlin]: ./src/_083/kotlin/Solution.kt
 [771-kotlin]: ./src/_771/kotlin/Solution.kt

src/_066/kotlin/Solution.kt

@@ -0,0 +1,41 @@
+package _066.kotlin
+
+import java.util.*
+
+/**
+ * @author relish
+ * @since 2018/04/19
+ */
+class Solution {
+    fun plusOne(digits: IntArray): IntArray {
+        var flag = 1
+        val len = digits.size
+        for (i in len - 1 downTo 0) {
+            digits[i] += flag
+            if (digits[i] >= 10) {
+                digits[i] %= 10
+                flag = 1
+                continue
+            }
+            flag = 0
+            break
+        }
+        if (flag == 1) {
+            return IntArray(len+1,fun(index: Int):Int{
+                if(index==0)return 1
+                return digits[index-1]
+            })
+        }
+        return digits
+    }
+}
+
+fun main(args: Array<String>) {
+    println(Arrays.toString(Solution().plusOne(intArrayOf(9, 9, 9, 9))))
+}
+//val ret = IntArray(len + 1)
+//ret[0] = 1
+//for (i in digits.indices) {
+//    ret[i + 1] = digits[i]
+//}
+//return ret

src/_067/kotlin/Solution.kt

@@ -0,0 +1,31 @@
+package _067.kotlin
+
+/**
+ * @author relish
+ * @since 2018/04/20
+ */
+class Solution {
+    fun addBinary(a: String, b: String): String {
+        val sb = StringBuilder()
+        var flag = 0
+        var i = a.length - 1
+        var j = b.length - 1
+        while (i >= 0 || j >= 0) {
+            val ta = if (i < 0) 0 else a[i] - '0'
+            val tb = if (j < 0) 0 else b[j] - '0'
+            val t = ta + tb + flag
+            flag = if (t > 1) 1 else 0
+            sb.append(if (t > 1) t - 2 else t)
+            i--
+            j--
+        }
+        if (flag == 1) {
+            sb.append('1')
+        }
+        return sb.reverse().toString()
+    }
+}
+
+fun main(args: Array<String>) {
+    println(Solution().addBinary("1111", "1111"))
+}

src/_069/kotlin/Solution.kt

@@ -0,0 +1,20 @@
+package _069.kotlin
+
+/**
+ * @author relish
+ * @since 2018/04/21
+ */
+class Solution {
+    fun mySqrt(x: Int): Int {
+        var k = x.toLong()
+        while (k * k > x)
+            k = (k + x / k) / 2
+        return k.toInt()
+    }
+}
+
+fun main(args: Array<String>) {
+    println(Solution().mySqrt(2147395599))
+    println(Solution().mySqrt(8))
+    println(Solution().mySqrt(120))
+}

src/_070/kotlin/Solution.kt

@@ -0,0 +1,27 @@
+package _070.kotlin
+
+/**
+ * @author relish
+ * @since 2018/04/22
+ */
+class Solution {
+    fun climbStairs(n: Int): Int {
+        if (n == 1) return 1
+        if (n == 2) return 2
+
+        var a = 1
+        var b = 2
+        var c: Int
+        for (i in 2 until n) {
+            c = b
+            b += a
+            a = c
+        }
+        return b
+    }
+}
+
+fun main(args: Array<String>) {
+    println(Solution().climbStairs(3))
+}
+

src/_083/kotlin/Solution.kt

@@ -0,0 +1,41 @@
+package _083.kotlin
+
+import structure.ListNode
+
+/**
+ * @author relish
+ * @since 2018/04/23
+ */
+/**
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int = 0) {
+ *     var next: ListNode? = null
+ * }
+ */
+class Solution {
+    fun deleteDuplicates(head: ListNode?): ListNode? {
+        if (head == null) return head
+        var cur = head
+        while (cur!!.next != null) {
+            if (cur.`val` == cur.next.`val`) {
+                cur.next = cur.next.next
+            } else {
+                cur = cur.next
+            }
+        }
+        return head
+    }
+}
+
+fun main(args: Array<String>) {
+    val n = ListNode(1)
+    n.next = ListNode(1)
+    n.next.next = ListNode(2)
+    n.next.next.next = ListNode(3)
+    n.next.next.next.next = ListNode(3)
+    var listNode = Solution().deleteDuplicates(n)
+    while (listNode != null) {
+        println(listNode.`val`)
+        listNode = listNode.next
+    }
+}

src/_671/Solution.java

@@ -0,0 +1,49 @@
+package _671;
+
+import java.util.Stack;
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int findSecondMinimumValue(TreeNode root) {
+        Stack<TreeNode> stack = new Stack<>();
+        int min = root.val;
+        int secMin = -1;
+        stack.push(root);
+
+        while (!stack.empty()) {
+            TreeNode node = stack.pop();
+
+            if (node.val > min) {
+                 if (node.val < secMin || secMin == -1) {
+                     secMin = node.val;
+                 }
+                 continue;
+            }
+
+            if (node.left != null) {
+                stack.push(node.right);
+                stack.push(node.left);
+            }
+        }
+
+        return secMin;
+    }
+
+    class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+
+        TreeNode(int x) {
+            val = x;
+        }
+    }
+}

src/_674/Solution.java

@@ -0,0 +1,28 @@
+package _674;
+
+class Solution {
+    public int findLengthOfLCIS(int[] nums) {
+        if (nums.length == 0) {
+            return 0;
+        }
+        int len = 1;
+        int maxLen = 1;
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] > nums[i-1]) {
+                len++;
+                if (len > maxLen) {
+                    maxLen = len;
+                }
+            } else {
+                len = 1;
+            }
+        }
+        return maxLen;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.findLengthOfLCIS(new int[] {1, 3, 5, 4, 7}));
+        System.out.println(solution.findLengthOfLCIS(new int[] {2, 2, 2, 2}));
+    }
+}

src/_680/Solution.java

@@ -0,0 +1,34 @@
+package _680;
+
+class Solution {
+    public boolean validPalindrome(String s) {
+        int l = 0;
+        int r = s.length() - 1;
+        while (l < r) {
+            if (s.charAt(l) != s.charAt(r)) {
+                return isPalindrome(s, l + 1, r) || isPalindrome(s, l, r - 1);
+            }
+            l++;
+            r--;
+        }
+        return l >= r;
+    }
+
+    private boolean isPalindrome(String s, int l, int r) {
+        while (l < r) {
+            if (s.charAt(l) != s.charAt(r)) {
+                return false;
+            }
+            l++;
+            r--;
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.validPalindrome("aba"));
+        System.out.println(solution.validPalindrome("abca"));
+        System.out.println(solution.validPalindrome("ececcec"));
+    }
+}

src/_682/Solution.java

@@ -0,0 +1,33 @@
+package _682;
+
+class Solution {
+    public int calPoints(String[] ops) {
+        int[] scores = new int[1000];
+        int sum = 0;
+        int i = 0;
+
+        for (String op : ops) {
+            if (op.charAt(0) == 'C') {
+                sum -= scores[i--];
+                continue;
+            }
+
+            i++;
+            if (op.charAt(0) == '+') {
+                scores[i] = scores[i-1] + scores[i-2];
+            } else if (op.charAt(0) == 'D') {
+                scores[i] = scores[i - 1] * 2;
+            } else {
+                scores[i] = Integer.valueOf(op);
+            }
+            sum += scores[i];
+        }
+
+        return sum;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.calPoints(new String[]{"5","-2","4","C","D","9","+","+"}));
+    }
+}