add 908

fishercoder1534 · fishercoder1534 · commit c0b239ed48a5 · 2019-01-01T19:03:26.000-08:00
diff --git a/README.md b/README.md
@@ -39,6 +39,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |925|[Long Pressed Name](https://leetcode.com/problems/long-pressed-name/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_925.java) | O(n) | O(1) | |Easy|
 |922|[Sort Array By Parity II](https://leetcode.com/problems/sort-array-by-parity-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_922.java) | O(n) | O(1) | |Easy|
 |917|[Reverse Only Letters](https://leetcode.com/problems/reverse-only-letters/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_917.java) | O(n) | O(n) | |Easy|
+|908|[Smallest Range I](https://leetcode.com/problems/smallest-range-i/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_908.java) | O(nlogn) | O(1) | |Easy|
 |900|[Sort Array By Parity](https://leetcode.com/problems/sort-array-by-parity/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_900.java) | O(n) | O(1) | |Easy|
 |897|[Increasing Order Search Tree](https://leetcode.com/problems/increasing-order-search-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_897.java) | O(n) | O(n) | |Easy| DFS, recursion
 |896|[Monotonic Array](https://leetcode.com/problems/monotonic-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_896.java) | O(n) | O(1) | |Easy|
diff --git a/src/main/java/com/fishercoder/solutions/_908.java b/src/main/java/com/fishercoder/solutions/_908.java
@@ -0,0 +1,53 @@
+package com.fishercoder.solutions;
+
+import java.util.Arrays;
+
+/**
+ * 908. Smallest Range I
+ *
+ * Given an array A of integers, for each integer A[i] we may choose any x with -K <= x <= K, and add x to A[i].
+ *
+ * After this process, we have some array B.
+ *
+ * Return the smallest possible difference between the maximum value of B and the minimum value of B.
+ *
+ *
+ *
+ * Example 1:
+ *
+ * Input: A = [1], K = 0
+ * Output: 0
+ * Explanation: B = [1]
+ * Example 2:
+ *
+ * Input: A = [0,10], K = 2
+ * Output: 6
+ * Explanation: B = [2,8]
+ * Example 3:
+ *
+ * Input: A = [1,3,6], K = 3
+ * Output: 0
+ * Explanation: B = [3,3,3] or B = [4,4,4]
+ *
+ *
+ * Note:
+ *
+ * 1 <= A.length <= 10000
+ * 0 <= A[i] <= 10000
+ * 0 <= K <= 10000
+ */
+public class _908 {
+  public static class Solution1 {
+    public int smallestRangeI(int[] A, int K) {
+      Arrays.sort(A);
+      int smallestPlus = A[0] + K;
+      int biggestMinus = A[A.length - 1] - K;
+      int diff = biggestMinus - smallestPlus;
+      if (diff > 0) {
+        return diff;
+      } else {
+        return 0;
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/fishercoder/_908Test.java b/src/test/java/com/fishercoder/_908Test.java
@@ -0,0 +1,35 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._908;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _908Test {
+  private static _908.Solution1 solution1;
+  private static int[] A;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _908.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    A = new int[] {1};
+    assertEquals(0, solution1.smallestRangeI(A, 0));
+  }
+
+  @Test
+  public void test2() {
+    A = new int[] {0, 10};
+    assertEquals(6, solution1.smallestRangeI(A, 2));
+  }
+
+  @Test
+  public void test3() {
+    A = new int[] {1, 3, 6};
+    assertEquals(0, solution1.smallestRangeI(A, 3));
+  }
+}
