refactored some algorithms in the other package

Author: DmitryTsyvtsyn

src/main/kotlin/other/BinaryDigitsCounter.kt

@@ -3,22 +3,18 @@ package other
 /**
  *
  * This algorithm counts the number of ones and zeros in a binary string
+ *
  * and implemented on a finite state machine
  *
  */
 
 class BinaryDigitsCounter {
-
-    /**
-     * Stores the result of the algorithm
-     */
+    
     data class Result(private val ones: Int = 0, private val zeros: Int = 0)
 
-    /**
-     * Represents two states
-     */
-    private enum class State {
-        ONE, ZERO
+    // represents two states
+    private enum class State { 
+        ONE, ZERO 
     }
 
     fun compute(binaryString: String): Result { // 1010010011

src/main/kotlin/other/Euclid.kt

@@ -8,20 +8,30 @@ package other
 
 class Euclid {
 
-    /**
-     * finds the greatest common divisor of two numbers and returns it
-     */
-    fun compute(num1: Int, num2: Int) : Int {
-        var copyNum1 = num1
-        var copyNum2 = num2
-        while (copyNum1 != 0 && copyNum2 != 0) {
-            if (copyNum1 > copyNum2) {
-                copyNum1 %= copyNum2
+    fun computeByDivisionWithRemainder(number1: Int, number2: Int) : Int {
+        var copyNumber1 = number1
+        var copyNumber2 = number2
+        while (copyNumber1 != 0 && copyNumber2 != 0) {
+            if (copyNumber1 > copyNumber2) {
+                copyNumber1 %= copyNumber2
             } else {
-                copyNum2 %= copyNum1
+                copyNumber2 %= copyNumber1
             }
         }
-        return copyNum1 + copyNum2
+        return copyNumber1 + copyNumber2
+    }
+
+    fun computeBySubtraction(number1: Int, number2: Int): Int {
+        var copyNumber1 = number1
+        var copyNumber2 = number2
+        while (copyNumber1 != copyNumber2) {
+            if (copyNumber1 > copyNumber2) {
+                copyNumber1 -= copyNumber2
+            } else {
+                copyNumber2 -= copyNumber1
+            }
+        }
+        return copyNumber1
     }
 
 }

src/main/kotlin/other/Factorial.kt

@@ -9,10 +9,9 @@ package other
 class Factorial {
 
     /**
+     * iterative method
      * worst time: O(n)
      * amount of memory: O(1)
-     *
-     * @return returns the factorial of a number by an iterative method
      */
     fun compute(number: Int) : Int {
         if (number <= 1) {
@@ -27,10 +26,9 @@ class Factorial {
     }
 
     /**
+     * recursive method
      * worst time: O(n)
      * amount of memory: O(n) - stack for recursion
-     *
-     * @return returns factorial recursively
      */
     fun computeRecursive(number: Int) : Int {
         return if (number <= 1) {
@@ -40,9 +38,7 @@ class Factorial {
         }
     }
 
-    /**
-     * @see <a href="https://kotlinlang.org/docs/functions.html#tail-recursive-functions">tailrec functions</a>
-     */
+    // read more: https://kotlinlang.org/docs/functions.html#tail-recursive-functions
     tailrec fun computeRecursiveWithKotlinOptimization(number: Int, result: Int = 1) : Int =
         if (number <= 1) result else computeRecursiveWithKotlinOptimization(number - 1, result * number)
 

src/main/kotlin/other/FactorialAdvanced.kt

@@ -10,6 +10,7 @@ import java.math.BigInteger
 
 class FactorialAdvanced {
 
+    // precomputed factorials
     private val factorials = longArrayOf(
         1L,
         1L,
@@ -43,37 +44,37 @@ class FactorialAdvanced {
             return BigInteger.valueOf(factorials[n])
         }
 
-        // Pre-allocate space for our list of intermediate BigIntegers.
+        // pre-allocate space for our list of intermediate BigIntegers.
         val approxSize = divide(n * log2Celling(n), Long.SIZE_BITS)
         val bigNumbers = ArrayList<BigInteger>(approxSize)
 
-        // Start from the pre-computed maximum long factorial.
+        // start from the pre-computed maximum long factorial.
         val startingNumber = factorials.size
         var number = factorials[startingNumber - 1]
-        // Strip off 2s from this value.
+        // strip off 2s from this value.
         var shift = number.countTrailingZeroBits()
         number = number shr shift
 
-        // Use floor(log2(num)) + 1 to prevent overflow of multiplication.
+        // use floor(log2(num)) + 1 to prevent overflow of multiplication.
         var numberBits = log2Floor(number) + 1
         var bits = log2Floor(startingNumber.toLong()) + 1
-        // Check for the next power of two boundary, to save us a CLZ operation.
+        // check for the next power of two boundary, to save us a CLZ operation.
         var nextPowerOfTwo = 1 shl bits - 1
 
-        // Iteratively multiply the longs as big as they can go.
+        // iteratively multiply the longs as big as they can go.
         for (num in startingNumber..n) {
-            // Check to see if the floor(log2(num)) + 1 has changed.
+            // check to see if the floor(log2(num)) + 1 has changed.
             if ((num and nextPowerOfTwo) != 0) {
                 nextPowerOfTwo = nextPowerOfTwo shl 1
                 bits++
             }
-            // Get rid of the 2s in num.
+            // get rid of the 2s in num.
             val tz = num.toLong().countTrailingZeroBits()
             val normalizedNum = (num shr tz).toLong()
             shift += tz
-            // Adjust floor(log2(num)) + 1.
+            // adjust floor(log2(num)) + 1.
             val normalizedBits = bits - tz
-            // If it won't fit in a long, then we store off the intermediate product.
+            // if it won't fit in a long, then we store off the intermediate product.
             if (normalizedBits + numberBits >= Long.SIZE_BITS) {
                 bigNumbers.add(BigInteger.valueOf(number))
                 number = 1
@@ -82,11 +83,11 @@ class FactorialAdvanced {
             number *= normalizedNum
             numberBits = log2Floor(number) + 1
         }
-        // Check for leftovers.
+        // check for leftovers.
         if (number > 1) {
             bigNumbers.add(BigInteger.valueOf(number))
         }
-        // Efficiently multiply all the intermediate products together.
+        // efficiently multiply all the intermediate products together.
         return listNumbers(bigNumbers).shiftLeft(shift)
     }
 
@@ -116,24 +117,21 @@ class FactorialAdvanced {
             2 -> numbers[start].multiply(numbers[start + 1])
             3 -> numbers[start].multiply(numbers[start + 1]).multiply(numbers[start + 2])
             else -> {
-                // Otherwise, split the list in half and recursively do this.
+                // otherwise, split the list in half and recursively do this.
                 val m = end + start ushr 1
                 listNumbers(numbers, start, m).multiply(listNumbers(numbers, m, end))
             }
         }
     }
 
-    /**
-     * returns the base-2 logarithm of number, rounded according to the celling.
-     */
+    // returns the base-2 logarithm of number, rounded according to the celling.
     private fun log2Celling(number: Int): Int {
         return Int.SIZE_BITS - (number - 1).countLeadingZeroBits()
     }
 
-    /**
-     * returns the base-2 logarithm of number rounded according to the floor.
-     */
+    // returns the base-2 logarithm of number rounded according to the floor.
     private fun log2Floor(number: Long): Int {
         return Long.SIZE_BITS - 1 - number.countLeadingZeroBits()
     }
+
 }

src/main/kotlin/other/FactorialBigWithCache.kt

@@ -17,13 +17,10 @@ class FactorialBigWithCache {
     private val cache = hashMapOf<Int, BigInteger>()
 
     /**
-     *
      * worst time: O(n)
      * the best time: O(1)
      * amount of memory: O(n)
      * problem: creating a huge number of BigInteger objects
-     *
-     * @return returns the factorial of a number
      */
     fun compute(number: Int) : BigInteger {
         if (number <= 1) {

src/main/kotlin/other/FactorialWithCache.kt

@@ -13,12 +13,9 @@ class FactorialWithCache {
     private val cache = hashMapOf<Int, Int>()
 
     /**
-     *
      * worst time: O(n)
      * the best time: O(1)
      * amount of memory: O(n)
-     *
-     * @return returns the factorial of a number
      */
     fun compute(number: Int) : Int {
         if (number <= 1) {

src/main/kotlin/other/FizzBuzz.kt

@@ -12,9 +12,7 @@ package other
 
 class FizzBuzz {
 
-    /**
-     * determines what to say for a number in the FizzBuzz game and returns Fizz, Buzz, FizzBuzz or number
-     */
+    // determines what to say for a number in the FizzBuzz game and returns Fizz, Buzz, FizzBuzz or number
     fun compute(number: Int) : String {
         return when {
             number % 3 == 0 && number % 5 == 0 -> "FizzBuzz"

src/test/kotlin/other/EuclidTest.kt

@@ -8,19 +8,27 @@ internal class EuclidTest {
     private val euclid = Euclid()
 
     @Test
-    fun test_one() {
-        assertEquals(5, euclid.compute(10, 5))
-        assertEquals(10, euclid.compute(10, 100))
-        assertEquals(9, euclid.compute(9, 27))
-        assertEquals(13, euclid.compute(26, 39))
+    fun `test computeByDivisionWithRemainder`() {
+        assertEquals(5, euclid.computeByDivisionWithRemainder(10, 5))
+        assertEquals(10, euclid.computeByDivisionWithRemainder(10, 100))
+        assertEquals(9, euclid.computeByDivisionWithRemainder(9, 27))
+        assertEquals(13, euclid.computeByDivisionWithRemainder(26, 39))
+        assertEquals(1, euclid.computeByDivisionWithRemainder(135, 13))
+        assertEquals(1, euclid.computeByDivisionWithRemainder(27, 19))
+        assertEquals(1, euclid.computeByDivisionWithRemainder(2, 17))
+        assertEquals(1, euclid.computeByDivisionWithRemainder(4, 9))
     }
 
     @Test
-    fun test_two() {
-        assertEquals(1, euclid.compute(135, 13))
-        assertEquals(1, euclid.compute(27, 19))
-        assertEquals(1, euclid.compute(2, 17))
-        assertEquals(1, euclid.compute(4, 9))
+    fun `test computeBySubtraction`() {
+        assertEquals(5, euclid.computeBySubtraction(10, 5))
+        assertEquals(10, euclid.computeBySubtraction(10, 100))
+        assertEquals(9, euclid.computeBySubtraction(9, 27))
+        assertEquals(13, euclid.computeBySubtraction(26, 39))
+        assertEquals(1, euclid.computeBySubtraction(135, 13))
+        assertEquals(1, euclid.computeBySubtraction(27, 19))
+        assertEquals(1, euclid.computeBySubtraction(2, 17))
+        assertEquals(1, euclid.computeBySubtraction(4, 9))
     }
 
 }