refactor 66

Author: fishercoder1534

src/main/java/com/fishercoder/solutions/_66.java

@@ -3,31 +3,38 @@
 /**
  * 66. Plus One
  *
- * Given a non-negative number represented as an array of digits, plus one to the number. The digits
- * are stored such that the most significant digit is at the head of the list.
+ * Given a non-empty array of digits representing a non-negative integer, plus one to the integer.
+ * The digits are stored such that the most significant digit is at the head of the list,
+ * and each element in the array contain a single digit.
+ *
+ * You may assume the integer does not contain any leading zero, except the number 0 itself.
+ *
+ * Example 1:
+ * Input: [1,2,3]
+ * Output: [1,2,4]
+ * Explanation: The array represents the integer 123.
+ *
+ * Example 2:
+ * Input: [4,3,2,1]
+ * Output: [4,3,2,2]
+ * Explanation: The array represents the integer 4321.
  */
 public class _66 {
 
   public static class Solution1 {
+      /**credit: https://leetcode.com/problems/plus-one/discuss/24082/My-Simple-Java-Solution*/
     public int[] plusOne(int[] digits) {
         int len = digits.length;
-        int[] temp = digits;
-        
         for (int i = len - 1; i >= 0; i--) {
-            if (temp[i] + 1 == 10) {
-                temp[i] = 0;
-            } else {
-                temp[i] += 1;
-                return temp;
+            if (digits[i] < 9) {
+                digits[i]++;
+                return digits;
             }
+            digits[i] = 0;
         }
-        if (temp[0] == 0) {
-            int[] res = new int[len + 1];
-            res[0] = 1; //all the rest of the numbers should all be zeroes, so we don't need to copy from the original array
-            return res;
-        } else {
-            return temp;
-        }
+        int[] newNumber = new int[len + 1];
+        newNumber[0] = 1;
+        return newNumber;
     }
   }
 }

src/test/java/com/fishercoder/_66Test.java

@@ -7,29 +7,29 @@
 import static org.junit.Assert.assertArrayEquals;
 
 public class _66Test {
-  private static _66.Solution1 solution1;
-  private static int[] digits;
+    private static _66.Solution1 solution1;
+    private static int[] digits;
 
-  @BeforeClass
-  public static void setup() {
-    solution1 = new _66.Solution1();
-  }
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _66.Solution1();
+    }
 
-  @Test
-  public void test1() {
-    digits = new int[] {9, 9, 9, 9};
-    assertArrayEquals(new int[] {1, 0, 0, 0, 0}, solution1.plusOne(digits));
-  }
+    @Test
+    public void test1() {
+        digits = new int[]{9, 9, 9, 9};
+        assertArrayEquals(new int[]{1, 0, 0, 0, 0}, solution1.plusOne(digits));
+    }
 
-  @Test
-  public void test2() {
-    digits = new int[] {8, 9, 9, 9};
-    assertArrayEquals(new int[] {9, 0, 0, 0}, solution1.plusOne(digits));
-  }
+    @Test
+    public void test2() {
+        digits = new int[]{8, 9, 9, 9};
+        assertArrayEquals(new int[]{9, 0, 0, 0}, solution1.plusOne(digits));
+    }
 
-  @Test
-  public void test3() {
-    digits = new int[] {2, 4, 9, 3, 9};
-    assertArrayEquals(new int[] {2, 4, 9, 4, 0}, solution1.plusOne(digits));
-  }
+    @Test
+    public void test3() {
+        digits = new int[]{2, 4, 9, 3, 9};
+        assertArrayEquals(new int[]{2, 4, 9, 4, 0}, solution1.plusOne(digits));
+    }
 }