refactor 556

fishercoder1534 · fishercoder1534 · commit 6f9c5b9d6a0c · 2019-06-30T09:33:17.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_556.java b/src/main/java/com/fishercoder/solutions/_556.java
@@ -15,44 +15,48 @@
  * Output: -1
  */
 public class _556 {
-    //credit: https://discuss.leetcode.com/topic/85759/this-problem-is-the-same-to-next-permutation-algorithm-only and https://discuss.leetcode.com/topic/85755/java-solution-like-next-permutation-problem-o-n
+    public static class Solution1 {
+        /**
+         * credit: https://discuss.leetcode.com/topic/85759/this-problem-is-the-same-to-next-permutation-algorithm-only and https://discuss.leetcode.com/topic/85755/java-solution-like-next-permutation-problem-o-n
+         */
 
-    public int nextGreaterElement(int n) {
-        char[] digits = String.valueOf(n).toCharArray();
-        int i = digits.length - 2;
-        while (i >= 0 && digits[i + 1] <= digits[i]) {
-            i--;
+        public int nextGreaterElement(int n) {
+            char[] digits = String.valueOf(n).toCharArray();
+            int i = digits.length - 2;
+            while (i >= 0 && digits[i + 1] <= digits[i]) {
+                i--;
+            }
+            if (i < 0) {
+                return -1;
+            }
+            int j = digits.length - 1;
+            while (j >= 0 && digits[j] <= digits[i]) {
+                j--;
+            }
+            swap(digits, i, j);
+            reverse(digits, i + 1);
+            try {
+                return Integer.parseInt(new String(digits));
+            } catch (Exception e) {
+                return -1;
+            }
         }
-        if (i < 0) {
-            return -1;
-        }
-        int j = digits.length - 1;
-        while (j >= 0 && digits[j] <= digits[i]) {
-            j--;
-        }
-        swap(digits, i, j);
-        reverse(digits, i + 1);
-        try {
-            return Integer.parseInt(new String(digits));
-        } catch (Exception e) {
-            return -1;
-        }
-    }
 
-    private void reverse(char[] a, int start) {
-        int i = start;
-        int j = a.length - 1;
-        while (i < j) {
-            swap(a, i, j);
-            i++;
-            j--;
+        private void reverse(char[] a, int start) {
+            int i = start;
+            int j = a.length - 1;
+            while (i < j) {
+                swap(a, i, j);
+                i++;
+                j--;
+            }
         }
-    }
 
-    private void swap(char[] a, int i, int j) {
-        char temp = a[i];
-        a[i] = a[j];
-        a[j] = temp;
+        private void swap(char[] a, int i, int j) {
+            char temp = a[i];
+            a[i] = a[j];
+            a[j] = temp;
+        }
     }
 
 }
diff --git a/src/test/java/com/fishercoder/_556Test.java b/src/test/java/com/fishercoder/_556Test.java
@@ -1,41 +1,36 @@
 package com.fishercoder;
 
 import com.fishercoder.solutions._556;
-import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 public class _556Test {
-    private static _556 test;
+    private static _556.Solution1 solution1;
     private static int n;
     private static int expected;
     private static int actual;
 
     @BeforeClass
     public static void setup() {
-        test = new _556();
-    }
-
-    @Before
-    public void setupForEachTest() {
+        solution1 = new _556.Solution1();
     }
 
     @Test
     public void test1() {
         n = 12;
         expected = 21;
-        actual = test.nextGreaterElement(n);
+        actual = solution1.nextGreaterElement(n);
         assertEquals(expected, actual);
     }
 
     @Test
     public void test2() {
         n = 21;
         expected = -1;
-        actual = test.nextGreaterElement(n);
+        actual = solution1.nextGreaterElement(n);
         assertEquals(expected, actual);
         assertTrue(Integer.MAX_VALUE > 1999999999);
     }
@@ -44,23 +39,23 @@ public void test2() {
     public void test3() {
         n = 1999999999;
         expected = -1;
-        actual = test.nextGreaterElement(n);
+        actual = solution1.nextGreaterElement(n);
         assertEquals(expected, actual);
     }
 
     @Test
     public void test4() {
         n = 12222333;
         expected = 12223233;
-        actual = test.nextGreaterElement(n);
+        actual = solution1.nextGreaterElement(n);
         assertEquals(expected, actual);
     }
 
     @Test
     public void test5() {
         n = 12443322;
         expected = 13222344;
-        actual = test.nextGreaterElement(n);
+        actual = solution1.nextGreaterElement(n);
         assertEquals(expected, actual);
     }
 
