Resolve "Sum of Root To Leaf Binary Numbers" problem

Author: dkoval

src/main/java/com/github/dkoval/leetcode/challenge/SumOfRootToLeafBinaryNumbers.java

@@ -0,0 +1,49 @@
+package com.github.dkoval.leetcode.challenge;
+
+import com.github.dkoval.leetcode.TreeNode;
+
+/**
+ * <a href="https://leetcode.com/problems/sum-of-root-to-leaf-binary-numbers/">Sum of Root To Leaf Binary Numbers</a>
+ * <p>
+ * You are given the root of a binary tree where each node has a value 0 or 1.
+ * Each root-to-leaf path represents a binary number starting with the most significant bit.
+ * <p>
+ * For example, if the path is 0 -> 1 -> 1 -> 0 -> 1, then this could represent 01101 in binary, which is 13.
+ * <p>
+ * For all leaves in the tree, consider the numbers represented by the path from the root to that leaf. Return the sum of these numbers.
+ * <p>
+ * The test cases are generated so that the answer fits in a 32-bits integer.
+ * <p>
+ * Constraints:
+ * <ul>
+ *  <li>The number of nodes in the tree is in the range [1, 1000].</li>
+ *  <li>Node.val is 0 or 1.</li>
+ * </ul>
+ */
+public interface SumOfRootToLeafBinaryNumbers {
+
+    int sumRootToLeaf(TreeNode root);
+
+    class SumOfRootToLeafBinaryNumbersRev2 implements SumOfRootToLeafBinaryNumbersRev1 {
+
+        @Override
+        public int sumRootToLeaf(TreeNode root) {
+            return traverse(root, 0);
+        }
+
+        private int traverse(TreeNode node, int x) {
+            if (node == null) {
+                return 0;
+            }
+
+            x *= 2;
+            x += node.val;
+
+            if (node.left == null && node.right == null) {
+                return x;
+            }
+
+            return traverse(node.left, x) + traverse(node.right, x);
+        }
+    }
+}

src/main/kotlin/com/github/dkoval/leetcode/challenge/SumOfRootToLeafBinaryNumbers.kt

@@ -0,0 +1,19 @@
+package com.github.dkoval.leetcode.challenge
+
+import com.github.dkoval.leetcode.TreeNode
+
+object SumOfRootToLeafBinaryNumbersRev1 : SumOfRootToLeafBinaryNumbers {
+
+    // O(N) time | O(N) space
+    override fun sumRootToLeaf(root: TreeNode?): Int = doSumRootToLeaf(root, 0)
+
+    private fun doSumRootToLeaf(root: TreeNode?, num: Int): Int {
+        if (root == null) return 0
+        val updatedNum = num * 2 + root.`val` // base2 to base10 conversion
+        if (root.left == null && root.right == null) {
+            // reached a leaf node
+            return updatedNum
+        }
+        return doSumRootToLeaf(root.left, updatedNum) + doSumRootToLeaf(root.right, updatedNum)
+    }
+}

src/main/kotlin/com/github/dkoval/leetcode/challenge/SumOfRootToLeafBinaryNumbersRev1.kt

@@ -1,16 +1,25 @@
 package com.github.dkoval.leetcode.challenge
 
 import com.github.dkoval.leetcode.TreeNode
+import com.github.dkoval.leetcode.challenge.SumOfRootToLeafBinaryNumbers.SumOfRootToLeafBinaryNumbersRev2
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Nested
+import org.junit.jupiter.api.extension.ExtensionContext
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.Arguments
-import org.junit.jupiter.params.provider.MethodSource
+import org.junit.jupiter.params.provider.ArgumentsProvider
+import org.junit.jupiter.params.provider.ArgumentsSource
+import org.junit.jupiter.params.support.ParameterDeclarations
+import java.util.stream.Stream
 
 internal class SumOfRootToLeafBinaryNumbersTest {
 
-    companion object {
-        @JvmStatic
-        fun input(): List<Arguments> = listOf(
+    class InputArgumentsProvider : ArgumentsProvider {
+
+        override fun provideArguments(
+            parameters: ParameterDeclarations,
+            context: ExtensionContext
+        ): Stream<out Arguments> = Stream.of(
             Arguments.of(
                 TreeNode(1).apply {
                     left = TreeNode(0).apply {
@@ -39,10 +48,28 @@ internal class SumOfRootToLeafBinaryNumbersTest {
         )
     }
 
-    @ParameterizedTest
-    @MethodSource("input")
-    fun `should return sum of root to leaf binary numbers`(root: TreeNode?, expected: Int) {
-        val actual = SumOfRootToLeafBinaryNumbers.sumRootToLeaf(root)
-        assertEquals(expected, actual)
+    @Nested
+    inner class SumOfRootToLeafBinaryNumbersRev1Test {
+
+        @ParameterizedTest
+        @ArgumentsSource(InputArgumentsProvider::class)
+        fun `should return sum of root to leaf binary numbers`(root: TreeNode?, expected: Int) {
+            SumOfRootToLeafBinaryNumbersRev1.test(root, expected)
+        }
+    }
+
+    @Nested
+    inner class SumOfRootToLeafBinaryNumbersRev2Test {
+
+        @ParameterizedTest
+        @ArgumentsSource(InputArgumentsProvider::class)
+        fun `should return sum of root to leaf binary numbers`(root: TreeNode?, expected: Int) {
+            SumOfRootToLeafBinaryNumbersRev2().test(root, expected)
+        }
     }
-}
+}
+
+private fun SumOfRootToLeafBinaryNumbers.test(root: TreeNode?, expected: Int) {
+    val actual = sumRootToLeaf(root)
+    assertEquals(expected, actual)
+}