LeastCommonMultiple: adjust javadocs, use assertj in tests, add YT link,

Add check for empty array

Author: andrei-punko

README.md

@@ -247,6 +247,7 @@ they contain enough code which describes implementation in a natural way.
 | Прохождение теста подтверждения практического навыка "средний" по Java на hh.ru                  | [Youtube](https://youtu.be/ja4nLzZSj3s) | -                                                                                                                                                                                   |
 | Декодирование шифра Цезаря                                                                       | [Youtube](https://youtu.be/pjQ9sYo5bVE) | [Code](src/main/java/by/andd3dfx/string/CaesarCipher.java)                                                                                                                          |
 | Прохождение теста подтверждения практического навыка "продвинутый" по Java на hh.ru              | [Youtube](https://youtu.be/ce3g0nIJl24) | -                                                                                                                                                                                   |
+| Поиск НОК для набора чисел                                                                       | [Youtube](https://youtu.be/jR0Ei_3O7EM) | [Code](src/main/java/by/andd3dfx/numeric/LeastCommonMultiple.java)                                                                                                                  |
 
 ## Materials & notes
 

src/main/java/by/andd3dfx/numeric/LeastCommonMultiple.java

@@ -4,13 +4,31 @@
 import java.util.Map;
 
 /**
- * See <a href="https://en.wikipedia.org/wiki/Least_common_multiple">article</a> in wiki
- * <p>
+ * <pre>
  * Find the least common multiple of numbers array
+ *
+ * Determination of least common multiple: <a href="https://en.wikipedia.org/wiki/Least_common_multiple">article in wiki</a>
+ * </pre>
+ *
+ * @see <a href="https://youtu.be/jR0Ei_3O7EM">Video solution</a>
  */
 public class LeastCommonMultiple {
 
+    /**
+     * НОК(4, 6) - ?
+     * 4 8 12 16 ...
+     * 6 12 18 24 ...
+     * НОК(4, 6) = 12
+     * <p>
+     * 4 = 2^2
+     * 6 = 2 * 3
+     * НОК(4, 6) = 2^2 * 3 = 12
+     */
     public static int find(int[] numbers) {
+        if (numbers.length == 0) {
+            throw new IllegalArgumentException("Numbers array should be populated!");
+        }
+
         Map<Integer, Integer> dividerNItsPowerMap = new HashMap<>();
         for (int number : numbers) {
             determineDividersAndTheirMaxPower(number, dividerNItsPowerMap);
@@ -23,30 +41,37 @@ public static int find(int[] numbers) {
         return result;
     }
 
-    private static void determineDividersAndTheirMaxPower(int number, Map<Integer, Integer> dividerAndItsPower) {
+    private static void determineDividersAndTheirMaxPower(int number, Map<Integer, Integer> dividerNItsPowerMap) {
         while (number > 1) {
             for (var divider = 2; divider <= number; divider++) {
                 var power = 0;
                 while (number % divider == 0) {
-                    number /= divider;
                     power++;
+                    number /= divider;
                 }
 
                 if (power > 0) {
-                    if (!dividerAndItsPower.containsKey(divider) || power > dividerAndItsPower.get(divider)) {
-                        dividerAndItsPower.put(divider, power);
+                    if (!dividerNItsPowerMap.containsKey(divider)
+                            || power > dividerNItsPowerMap.get(divider)) {
+                        dividerNItsPowerMap.put(divider, power);
                     }
                 }
             }
         }
     }
 
+    /**
+     * НОК(a,b) = (a*b) / НОД(a,b)
+     */
     public static int find_usingGCD(int[] numbers) {
+        if (numbers.length == 0) {
+            throw new IllegalArgumentException("Numbers array should be populated!");
+        }
+
         var result = numbers[0];
         for (int i = 1; i < numbers.length; i++) {
             result = findForPair(result, numbers[i]);
         }
-
         return result;
     }
 

src/test/java/by/andd3dfx/numeric/LeastCommonMultipleTest.java

@@ -2,36 +2,46 @@
 
 import org.junit.Test;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static by.andd3dfx.numeric.LeastCommonMultiple.find;
+import static by.andd3dfx.numeric.LeastCommonMultiple.find_usingGCD;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertThrows;
 
 public class LeastCommonMultipleTest {
 
     @Test
     public void testFind() {
-        assertThat(LeastCommonMultiple.find(new int[]{10}), is(10));
-        assertThat(LeastCommonMultiple.find(new int[]{11}), is(11));
+        assertThrows("Numbers array should be populated!",
+                IllegalArgumentException.class, () -> find(new int[]{}));
 
-        assertThat(LeastCommonMultiple.find(new int[]{2, 3}), is(6));
-        assertThat(LeastCommonMultiple.find(new int[]{4, 6}), is(12));
-        // 6240 = 10*4*2*2*39
-        // 6800 = 10*4*2*5*17
-        assertThat(LeastCommonMultiple.find(new int[]{6240, 6800}), is(10 * 4 * 2 * 2 * 39 * 5 * 17));
+        assertThat(find(new int[]{10})).isEqualTo(10);
+        assertThat(find(new int[]{11})).isEqualTo(11);
 
-        assertThat(LeastCommonMultiple.find(new int[]{6, 9, 20}), is(180));
+        assertThat(find(new int[]{2, 3})).isEqualTo(6);
+        assertThat(find(new int[]{4, 6})).isEqualTo(12);
+        // 6240 = 2^5 * 3 * 5 * 13
+        // 6800 = 2^4 * 5^2 * 17
+        // НОК(6240, 6800) = 2^5 * 3 * 5^2 * 13 * 17
+        assertThat(find(new int[]{6240, 6800})).isEqualTo(530_400);
+
+        assertThat(find(new int[]{6, 9, 20})).isEqualTo(180);
     }
 
     @Test
     public void testFind_usingGCD() {
-        assertThat(LeastCommonMultiple.find_usingGCD(new int[]{10}), is(10));
-        assertThat(LeastCommonMultiple.find_usingGCD(new int[]{11}), is(11));
+        assertThrows("Numbers array should be populated!",
+                IllegalArgumentException.class, () -> find_usingGCD(new int[]{}));
+
+        assertThat(find_usingGCD(new int[]{10})).isEqualTo(10);
+        assertThat(find_usingGCD(new int[]{11})).isEqualTo(11);
 
-        assertThat(LeastCommonMultiple.find_usingGCD(new int[]{2, 3}), is(6));
-        assertThat(LeastCommonMultiple.find_usingGCD(new int[]{4, 6}), is(12));
-        // 6240 = 10*4*2*2*39
-        // 6800 = 10*4*2*5*17
-        assertThat(LeastCommonMultiple.find_usingGCD(new int[]{6240, 6800}), is(10 * 4 * 2 * 2 * 39 * 5 * 17));
+        assertThat(find_usingGCD(new int[]{2, 3})).isEqualTo(6);
+        assertThat(find_usingGCD(new int[]{4, 6})).isEqualTo(12);
+        // 6240 = 2^5 * 3 * 5 * 13
+        // 6800 = 2^4 * 5^2 * 17
+        // НОК(6240, 6800) = 2^5 * 3 * 5^2 * 13 * 17
+        assertThat(find_usingGCD(new int[]{6240, 6800})).isEqualTo(530_400);
 
-        assertThat(LeastCommonMultiple.find_usingGCD(new int[]{6, 9, 20}), is(180));
+        assertThat(find_usingGCD(new int[]{6, 9, 20})).isEqualTo(180);
     }
 }