0080. Remove Duplicates from Sorted Array II

Author: coderbean

markdown/0080. Remove Duplicates from Sorted Array II.md

@@ -0,0 +1,67 @@
+### [80\. Remove Duplicates from Sorted Array II](https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/)
+
+Difficulty: **Medium**
+
+
+Given a sorted array _nums_, remove the duplicates such that duplicates appeared at most _twice_ and return the new length.
+
+Do not allocate extra space for another array, you must do this by **modifying the input array** with O(1) extra memory.
+
+**Example 1:**
+
+```
+Given nums = [1,1,1,2,2,3],
+
+Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively.
+
+It doesn't matter what you leave beyond the returned length.
+```
+
+**Example 2:**
+
+```
+Given nums = [0,0,1,1,1,1,2,3,3],
+
+Your function should return length = 7, with the first seven elements of nums being modified to 0, 0, 1, 1, 2, 3 and 3 respectively.
+
+It doesn't matter what values are set beyond the returned length.
+```
+
+**Clarification:**
+
+Confused why the returned value is an integer but your answer is an array?
+
+Note that the input array is passed in by **reference**, which means modification to the input array will be known to the caller as well.
+
+Internally you can think of this:
+
+```
+// nums is passed in by reference. (i.e., without making a copy)
+int len = removeDuplicates(nums);
+
+// any modification to nums in your function would be known by the caller.
+// using the length returned by your function, it prints the first len elements.
+for (int i = 0; i < len; i++) {
+    print(nums[i]);
+}
+```
+
+
+#### Solution
+
+Language: **Java**
+
+```java
+class Solution {
+    public int removeDuplicates(int[] nums) {
+        int i = 0;
+        for (int num : nums) {
+            if (i < 2 || num > nums[i - 2]) {
+                nums[i++] = num;
+            }
+        }
+        return i;
+    }
+}
+```
+![pic](https://raw.githubusercontent.com/PicGoBed/PicBed/master/2019-07-26-Dsh2ou.jpg)

src/main/java/leetcode/_80_/Main.java

@@ -0,0 +1,22 @@
+package leetcode._80_;
+
+import leetcode.common.Printer;
+
+/**
+ * Created by zhangbo54 on 2019-03-04.
+ */
+public class Main {
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        int[] nums = {1, 1, 1, 2, 2, 3};
+        System.out.println(solution.removeDuplicates(nums));
+        Printer.printArrays(nums);
+
+
+        int[] nums1 = {0, 0, 1, 1, 1, 1, 2, 3, 3};
+        System.out.println(solution.removeDuplicates(nums1));
+        Printer.printArrays(nums1);
+
+    }
+}
+

src/main/java/leetcode/_80_/Solution.java

@@ -0,0 +1,13 @@
+package leetcode._80_;
+
+class Solution { // 当看到这个解法的时候，我只能说一句：真 tmd 牛逼
+    public int removeDuplicates(int[] nums) {
+        int i = 0;
+        for (int num : nums) {
+            if (i < 2 || num > nums[i - 2]) {
+                nums[i++] = num;
+            }
+        }
+        return i;
+    }
+}

src/main/java/leetcode/_80_/solution.md

@@ -0,0 +1,67 @@
+### [80\. Remove Duplicates from Sorted Array II](https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/)
+
+Difficulty: **Medium**
+
+
+Given a sorted array _nums_, remove the duplicates such that duplicates appeared at most _twice_ and return the new length.
+
+Do not allocate extra space for another array, you must do this by **modifying the input array** with O(1) extra memory.
+
+**Example 1:**
+
+```
+Given nums = [1,1,1,2,2,3],
+
+Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively.
+
+It doesn't matter what you leave beyond the returned length.
+```
+
+**Example 2:**
+
+```
+Given nums = [0,0,1,1,1,1,2,3,3],
+
+Your function should return length = 7, with the first seven elements of nums being modified to 0, 0, 1, 1, 2, 3 and 3 respectively.
+
+It doesn't matter what values are set beyond the returned length.
+```
+
+**Clarification:**
+
+Confused why the returned value is an integer but your answer is an array?
+
+Note that the input array is passed in by **reference**, which means modification to the input array will be known to the caller as well.
+
+Internally you can think of this:
+
+```
+// nums is passed in by reference. (i.e., without making a copy)
+int len = removeDuplicates(nums);
+
+// any modification to nums in your function would be known by the caller.
+// using the length returned by your function, it prints the first len elements.
+for (int i = 0; i < len; i++) {
+    print(nums[i]);
+}
+```
+
+
+#### Solution
+
+Language: **Java**
+
+```java
+class Solution {
+    public int removeDuplicates(int[] nums) {
+        int i = 0;
+        for (int num : nums) {
+            if (i < 2 || num > nums[i - 2]) {
+                nums[i++] = num;
+            }
+        }
+        return i;
+    }
+}
+```
+![pic](https://raw.githubusercontent.com/PicGoBed/PicBed/master/2019-07-26-Dsh2ou.jpg)

src/main/java/leetcode/common/Printer.java

@@ -14,6 +14,7 @@ public static void printArrays(int[] arrays) {
             System.out.print(arrays[i] + ",");
         }
         System.out.print(arrays[arrays.length - 1] + "]");
+        System.out.println();
     }
 
     public static void printArrays(int[][] arrays) {