refactor 25

Author: fishercoder1534

README.md

@@ -4,7 +4,7 @@ _If you like this project, please give me a star._ ★
 
 > ["For coding interview preparation, LeetCode is one of the best online resource providing a rich library of more than 300 real coding interview questions for you to practice from using one of the 7 supported languages - C, C++, Java, Python, C#, JavaScript, Ruby."](https://www.quora.com/How-effective-is-Leetcode-for-preparing-for-technical-interviews)
 
-###If you feel benefited from Leetcode and loves it, please consider to [donate to Leetcode](https://leetcode.com/donate/) in order to help us build the best OJ platform.
+##If you feel benefited from Leetcode and loves it, please consider to [donate to Leetcode](https://leetcode.com/donate/) in order to help us build the best OJ platform.
 
 ## Contributing
 Your ideas/fixes/algorithms are more than welcome!

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

@@ -1,16 +1,14 @@
 package com.fishercoder.solutions;
 
 import com.fishercoder.common.classes.ListNode;
-import com.fishercoder.common.utils.CommonUtils;
 
 /**
+ * 25. Reverse Nodes in k-Group
  * Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.
-
- k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.
-
- You may not alter the values in the nodes, only nodes itself may be changed.
-
- Only constant memory is allowed.
+ * k is a positive integer and is less than or equal to the length of the linked list.
+ * If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.
+ * You may not alter the values in the nodes, only nodes itself may be changed.
+ * Only constant memory is allowed.
 
  For example,
  Given this linked list: 1->2->3->4->5
@@ -19,8 +17,11 @@
 
  For k = 3, you should return: 3->2->1->4->5
  */
+
 public class _25 {
 
+    /**We use recursion to go all the way until the end: when the number of nodes are smaller than k;
+     * then we start to reverse each group of k nodes from the end towards the start.*/
     public ListNode reverseKGroup(ListNode head, int k) {
         ListNode curr = head;
         int count = 0;
@@ -31,31 +32,21 @@ public ListNode reverseKGroup(ListNode head, int k) {
         }
 
         if (count == k) {
-            //if k+1 is found
-            curr = reverseKGroup(curr, k);//reverse list that has k+1 as head
+            /**after this below recursive call finishes, it'll return head;
+             * then this returned "head" will become "curr", while the head
+             * in its previous callstack is the real head after this call.
+             * Setting up a break point will make all of this crystal clear.*/
+            curr = reverseKGroup(curr, k);
 
-            while (count > 0) {
+            while (count-- > 0) {
                 ListNode temp = head.next;
                 head.next = curr;
                 curr = head;
                 head = temp;
-                count--;
             }
             head = curr;
         }
         return head;//we run out of nodes before we hit count == k, so we'll just directly return head in this case as well
     }
 
-    public static void main(String... args) {
-        ListNode head = new ListNode(1);
-        head.next = new ListNode(2);
-        head.next.next = new ListNode(3);
-        head.next.next.next = new ListNode(4);
-        head.next.next.next.next = new ListNode(5);
-
-        CommonUtils.printList(head);
-        _25 test = new _25();
-        CommonUtils.printList(test.reverseKGroup(head, 2));
-    }
-
-}
+}

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

@@ -60,4 +60,18 @@ public int findMinMoves(int[] machines) {
         }
         return max;
     }
+
+    public static class Solution2 {
+        /**TODO: finish it.*/
+        public int findMinMoves(int[] machines) {
+            int totalDresses = 0;
+            for (int i = 0; i < machines.length; i++) {
+                totalDresses += machines[i];
+            }
+            if (totalDresses / machines.length == 0 || totalDresses % machines.length != 0) {
+                return -1;
+            }
+            return -1;
+        }
+    }
 }

src/test/java/com/fishercoder/_25Test.java

@@ -0,0 +1,30 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.ListNode;
+import com.fishercoder.common.utils.LinkedListUtils;
+import com.fishercoder.solutions._25;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _25Test {
+    private static _25 test;
+    private static ListNode actual;
+    private static ListNode expected;
+    private static ListNode head;
+
+    @BeforeClass
+    public static void setup() {
+        test = new _25();
+    }
+
+    @Test
+    public void test1() {
+        head = LinkedListUtils.contructLinkedList(new int[]{1, 2, 3, 4, 5});
+        actual = test.reverseKGroup(head, 2);
+        expected = LinkedListUtils.contructLinkedList(new int[]{2, 1, 4, 3, 5});
+        assertEquals(actual, expected);
+    }
+
+}