From 8ad00c1957409d0d728692f13fee0f938e09a300 Mon Sep 17 00:00:00 2001
From: X BELL <194058603+bellxalli@users.noreply.github.com>
Date: Tue, 23 Sep 2025 11:48:19 -0700
Subject: [PATCH 01/10] completed oddSum method and shortestWord method

---
 src/Practice.java     |  49 ++-
 src/PracticeTest.java | 974 +++++++++++++++++++++---------------------
 2 files changed, 532 insertions(+), 491 deletions(-)

diff --git a/src/Practice.java b/src/Practice.java
index 01da8d0..5b8a602 100644
--- a/src/Practice.java
+++ b/src/Practice.java
@@ -1,5 +1,6 @@
-import java.util.Map;
-import java.util.Set;
+// import java.util.Map;
+// import java.util.Set;
+import java.util.*;
 
 public class Practice {
     /**
@@ -11,7 +12,21 @@ public class Practice {
      * @return the sum of the odd numbers in the array
      */
     public static int oddSum(int[] nums) {
-        return 0;
+        int sum  = 0;
+
+        if(nums == null)
+        {
+            return 0;
+        }
+
+        for(int i = 0; i < nums.length; i++)
+        {
+            if(nums[i] % 2 != 0)
+            {
+                sum += nums[i];
+            }
+        }
+        return sum;
     }
 
     /**
@@ -26,7 +41,33 @@ public static int oddSum(int[] nums) {
      * @throws NullPointerException if words is null
      */
     public static String shortestWord(Set<String> words) {
-        return null;
+        if(words == null)
+            throw new NullPointerException("words is null");
+        if(words.isEmpty())
+            throw new IllegalArgumentException("words is empty");
+
+        String smallest = "";
+        for(String word : words) //to get a word for starting length is not 0
+        {
+            smallest = word;
+            break;
+        }
+
+        for(String word : words)
+        {
+            if(word.length() < smallest.length())
+            {
+                smallest = word;
+            }
+            else if(smallest.length() == word.length())
+            {
+                if(smallest.compareTo(word) > 0)
+                {
+                    smallest = word;
+                }
+            }
+        }
+        return smallest;
     }
 
     /**
diff --git a/src/PracticeTest.java b/src/PracticeTest.java
index 8081e24..c629d79 100644
--- a/src/PracticeTest.java
+++ b/src/PracticeTest.java
@@ -60,491 +60,491 @@ void shortestWord_allSameLength() {
         assertEquals("ape", Practice.shortestWord(words));
     }
 
-    // ===== adults ============================================================
-
-    @Test
-    void adults_mixedAgesWithBoundaryIncluded() {
-        Map<String, Integer> ages = new HashMap<>();
-        ages.put("Ana", 17);
-        ages.put("Ben", 18);
-        ages.put("Caz", 41);
-        ages.put("Dee", 16);
-        ages.put("Eli", 18);
-
-        Set<String> result = Practice.adults(ages);
-        Set<String> expected = new HashSet<>(Arrays.asList("Ben", "Caz", "Eli"));
-
-        assertEquals(expected, result);
-    }
-
-    @Test
-    void adults_emptyInputGivesEmptySet() {
-        Map<String, Integer> ages = new HashMap<>();
-        assertTrue(Practice.adults(ages).isEmpty());
-    }
-
-    @Test
-    void adults_noAdultsAllUnder18() {
-        Map<String, Integer> ages = new HashMap<>();
-        ages.put("Ira", 6);
-        ages.put("Jay", 12);
-        ages.put("Kai", 17);
-        assertTrue(Practice.adults(ages).isEmpty());
-    }
-
-    // ===== biggestNumber =====================================================
-
-    @Test
-    void biggestNumber_mixedPosNegAndDuplicates() {
-        /*
-         * List:
-         *   5 -> -11 -> 42 -> 7 -> 42 -> -3 -> 0
-         */
-        ListNode<Integer> head = new ListNode<>(5,
-            new ListNode<>(-11,
-                new ListNode<>(42,
-                    new ListNode<>(7,
-                        new ListNode<>(42,
-                            new ListNode<>(-3,
-                                new ListNode<>(0, null)))))));
-
-        assertEquals(42, Practice.biggestNumber(head));
-    }
-
-    @Test
-    void biggestNumber_singleNodeNegative() {
-        /*
-         * List:
-         *   -8
-         */
-        ListNode<Integer> head = new ListNode<>(-8, null);
-        assertEquals(-8, Practice.biggestNumber(head));
-    }
-
-    @Test
-    void biggestNumber_allEqualValues() {
-        /*
-         * List:
-         *   13 -> 13 -> 13
-         */
-        ListNode<Integer> head = new ListNode<>(13,
-            new ListNode<>(13,
-                new ListNode<>(13, null)));
-        assertEquals(13, Practice.biggestNumber(head));
-    }
-
-    // ===== frequencies =======================================================
-
-    @Test
-    void frequencies_stringsExampleFromSpecPlusMore() {
-        /*
-         * List:
-         *   a -> x -> a -> a -> x -> y -> z -> y
-         * Expected: {a=3, x=2, y=2, z=1}
-         */
-        ListNode<String> head = new ListNode<>("a",
-            new ListNode<>("x",
-                new ListNode<>("a",
-                    new ListNode<>("a",
-                        new ListNode<>("x",
-                            new ListNode<>("y",
-                                new ListNode<>("z",
-                                    new ListNode<>("y", null))))))));
-
-        Map<String, Integer> expected = new HashMap<>();
-        expected.put("a", 3);
-        expected.put("x", 2);
-        expected.put("y", 2);
-        expected.put("z", 1);
-
-        assertEquals(expected, Practice.frequencies(head));
-    }
-
-    @Test
-    void frequencies_integersArbitraryOrder() {
-        /*
-         * List:
-         *   7 -> 9 -> 7 -> 7 -> 10 -> 9 -> 10 -> 7 -> 10 -> 10 -> 10
-         * Expected: {7=4, 9=2, 10=5}
-         */
-        ListNode<Integer> head = new ListNode<>(7,
-            new ListNode<>(9,
-                new ListNode<>(7,
-                    new ListNode<>(7,
-                        new ListNode<>(10,
-                            new ListNode<>(9,
-                                new ListNode<>(10,
-                                    new ListNode<>(7,
-                                        new ListNode<>(10,
-                                            new ListNode<>(10,
-                                                new ListNode<>(10, null)))))))))));
-
-        Map<Integer, Integer> expected = new HashMap<>();
-        expected.put(7, 4);
-        expected.put(9, 2);
-        expected.put(10, 5);
-
-        assertEquals(expected, Practice.frequencies(head));
-    }
-
-    @Test
-    void frequencies_nullHeadReturnsEmptyMap() {
-        ListNode<String> head = null;
-        assertTrue(Practice.frequencies(head).isEmpty());
-    }
-
-    // ===== levelCount ========================================================
-
-    @Test
-    void levelCount_nullRootIsZero() {
-        BinaryTreeNode<Integer> root = null;
-        assertEquals(0, Practice.levelCount(root));
-    }
-
-    @Test
-    void levelCount_singleNodeIsOne() {
-        /*
-         *   42
-         */
-        BinaryTreeNode<Integer> root = new BinaryTreeNode<>(42);
-        assertEquals(1, Practice.levelCount(root));
-    }
-
-    @Test
-    void levelCount_balancedThreeLevels() {
-        /*
-         *        8
-         *      /   \
-         *     3     10
-         *    / \      \
-         *   1   6      14
-         */
-        BinaryTreeNode<Integer> root =
-            new BinaryTreeNode<>(8,
-                new BinaryTreeNode<>(3,
-                    new BinaryTreeNode<>(1),
-                    new BinaryTreeNode<>(6)),
-                new BinaryTreeNode<>(10,
-                    null,
-                    new BinaryTreeNode<>(14)));
-        assertEquals(3, Practice.levelCount(root));
-    }
-
-    @Test
-    void levelCount_unbalancedDeeperLeft() {
-        /*
-         *       5
-         *      /
-         *     4
-         *    /
-         *   3
-         *    \
-         *     2
-         *    /
-         *   1
-         */
-        BinaryTreeNode<Integer> root =
-            new BinaryTreeNode<>(5,
-                new BinaryTreeNode<>(4,
-                    new BinaryTreeNode<>(3,
-                        null,
-                        new BinaryTreeNode<>(2,
-                            new BinaryTreeNode<>(1),
-                            null)),
-                    null),
-                null);
-        assertEquals(5, Practice.levelCount(root));
-    }
-
-    // ===== sumAtLevel ========================================================
-
-    @Test
-    void sumAtLevel_exampleFromSpec_level3Is18() {
-        /*
-         *       5
-         *     /   \
-         *    8     4
-         *   / \   /
-         *  7  9  2
-         *    /
-         *   1
-         * Level 3 nodes: 7, 9, 2 -> sum = 18
-         */
-        BinaryTreeNode<Integer> root =
-            new BinaryTreeNode<>(5,
-                new BinaryTreeNode<>(8,
-                    new BinaryTreeNode<>(7),
-                    new BinaryTreeNode<>(9,
-                        new BinaryTreeNode<>(1),
-                        null)),
-                new BinaryTreeNode<>(4,
-                    new BinaryTreeNode<>(2),
-                    null));
-
-        assertEquals(18, Practice.sumAtLevel(root, 3));
-    }
-
-    @Test
-    void sumAtLevel_level1IsRootValue() {
-        /*
-         *    12
-         *   /  \
-         *  7    5
-         */
-        BinaryTreeNode<Integer> root =
-            new BinaryTreeNode<>(12,
-                new BinaryTreeNode<>(7),
-                new BinaryTreeNode<>(5));
-
-        assertEquals(12, Practice.sumAtLevel(root, 1));
-    }
-
-    @Test
-    void sumAtLevel_levelBeyondDepthIsZero() {
-        /*
-         *   9
-         *    \
-         *     2
-         */
-        BinaryTreeNode<Integer> root =
-            new BinaryTreeNode<>(9,
-                null,
-                new BinaryTreeNode<>(2));
-        assertEquals(0, Practice.sumAtLevel(root, 5));
-    }
-
-    @Test
-    void sumAtLevel_levelZeroIsNotPresentSoZero() {
-        /*
-         *   3
-         */
-        BinaryTreeNode<Integer> root = new BinaryTreeNode<>(3);
-        assertEquals(0, Practice.sumAtLevel(root, 0));
-    }
-
-    @Test
-    void sumAtLevel_emptyTreeIsZero() {
-        BinaryTreeNode<Integer> root = null;
-        assertEquals(0, Practice.sumAtLevel(root, 2));
-    }
-
-    // ===== sumMatch ==========================================================
-
-    @Test
-    void sumMatch_equalSumsNonEmpty() {
-        /*
-         * Tree:
-         *      6
-         *     / \
-         *    4   1
-         *   / \
-         *  -2  7
-         * Tree sum = 6 + 4 + 1 + (-2) + 7 = 16
-         *
-         * List:
-         *  10 -> 3 -> 3
-         * List sum = 16
-         */
-        BinaryTreeNode<Integer> root =
-            new BinaryTreeNode<>(6,
-                new BinaryTreeNode<>(4,
-                    new BinaryTreeNode<>(-2),
-                    new BinaryTreeNode<>(7)),
-                new BinaryTreeNode<>(1));
-
-        ListNode<Integer> head = new ListNode<>(10,
-            new ListNode<>(3,
-                new ListNode<>(3, null)));
-
-        assertTrue(Practice.sumMatch(root, head));
-    }
-
-    @Test
-    void sumMatch_notEqual() {
-        /*
-         * Tree:
-         *    5
-         *   / \
-         *  2   2
-         * Sum = 9
-         *
-         * List:
-         *  4 -> 4
-         * Sum = 8
-         */
-        BinaryTreeNode<Integer> root =
-            new BinaryTreeNode<>(5,
-                new BinaryTreeNode<>(2),
-                new BinaryTreeNode<>(2));
-
-        ListNode<Integer> head = new ListNode<>(4,
-            new ListNode<>(4, null));
-
-        assertFalse(Practice.sumMatch(root, head));
-    }
-
-    @Test
-    void sumMatch_bothEmptyAreZeroSoTrue() {
-        BinaryTreeNode<Integer> root = null;
-        ListNode<Integer> head = null;
-        assertTrue(Practice.sumMatch(root, head));
-    }
-
-    @Test
-    void sumMatch_emptyTreeNonEmptyListFalse() {
-        BinaryTreeNode<Integer> root = null;
-        /*
-         * List:
-         *   1 -> 2
-         */
-        ListNode<Integer> head = new ListNode<>(1, new ListNode<>(2, null));
-        assertFalse(Practice.sumMatch(root, head));
-    }
-
-    // ===== graphSum & sinkCount (directed; neighbors = outgoing) =============
-
-    @Test
-    void graphSum_cyclicComponentPlusDetachedVertex() {
-        /*
-         * Vertices (values):
-         *   v1(5), v2(7), v3(-2), v4(10), v5(1), v6(3)
-         *
-         * Edges (directed), includes cycles:
-         *   v1 -> v2, v3
-         *   v2 -> v4
-         *   v3 -> v2, v5
-         *   v4 -> v1           // cycle v1 -> v2 -> v4 -> v1
-         *   v5 -> v3           // cycle v3 <-> v5
-         *   v6 -> (none)       // detached sink (not reachable from v1)
-         *
-         * From v1, reachable: {v1,v2,v3,v4,v5}
-         * Sum = 5 + 7 + (-2) + 10 + 1 = 21
-         */
-        Vertex<Integer> v1 = new Vertex<>(5);
-        Vertex<Integer> v2 = new Vertex<>(7);
-        Vertex<Integer> v3 = new Vertex<>(-2);
-        Vertex<Integer> v4 = new Vertex<>(10);
-        Vertex<Integer> v5 = new Vertex<>(1);
-        Vertex<Integer> v6 = new Vertex<>(3);
-
-        v1.neighbors.add(v2);
-        v1.neighbors.add(v3);
-
-        v2.neighbors.add(v4);
-
-        v3.neighbors.add(v2);
-        v3.neighbors.add(v5);
-
-        v4.neighbors.add(v1);
-
-        v5.neighbors.add(v3);
-
-        // v6 has no neighbors
-
-        assertEquals(21, Practice.graphSum(v1));
-        assertEquals(3, Practice.graphSum(v6));  // only itself
-        assertEquals(0, Practice.graphSum(null));
-    }
-
-    @Test
-    void sinkCount_cyclicComponentWithOneReachableSinkAndOneUnreachableSink() {
-        /*
-         * Values:
-         *   a(10), b(4), c(7), d(2), e(9), f(4)
-         *
-         * Edges (directed):
-         *   a -> b, c
-         *   b -> d
-         *   c -> b, e
-         *   d -> a              // cycle a -> b -> d -> a
-         *   e -> c              // cycle c <-> e
-         *   f -> (none)         // unreachable sink from a
-         *
-         * Also add a reachable sink g(5):
-         *   g -> (none)
-         *   and connect c -> g
-         *
-         * From a, sinks reachable: only g
-         * So sinkCount(a) = 1
-         * From f, sinks reachable: f itself, so sinkCount(f) = 1
-         */
-        Vertex<Integer> a = new Vertex<>(10);
-        Vertex<Integer> b = new Vertex<>(4);
-        Vertex<Integer> c = new Vertex<>(7);
-        Vertex<Integer> d = new Vertex<>(2);
-        Vertex<Integer> e = new Vertex<>(9);
-        Vertex<Integer> f = new Vertex<>(4);
-        Vertex<Integer> g = new Vertex<>(5);
-
-        a.neighbors.add(b);
-        a.neighbors.add(c);
-
-        b.neighbors.add(d);
-
-        c.neighbors.add(b);
-        c.neighbors.add(e);
-
-        d.neighbors.add(a);
-
-        e.neighbors.add(c);
-
-        // f -> (none)
-        // g -> (none)
-        c.neighbors.add(g); // make g reachable from a via c
-
-        assertEquals(1, Practice.sinkCount(a)); // only g is sink and reachable
-        assertEquals(1, Practice.sinkCount(f)); // f is a sink by itself
-    }
-
-    @Test
-    void sinkCount_cyclicNoSinksReachable() {
-        /*
-         * Values:
-         *   x(1), y(2), z(3)
-         * Edges:
-         *   x -> y
-         *   y -> z
-         *   z -> x   // 3-cycle, all outdegree > 0
-         * From x, there are no reachable sinks.
-         */
-        Vertex<Integer> x = new Vertex<>(1);
-        Vertex<Integer> y = new Vertex<>(2);
-        Vertex<Integer> z = new Vertex<>(3);
-
-        x.neighbors.add(y);
-        y.neighbors.add(z);
-        z.neighbors.add(x);
-
-        assertEquals(0, Practice.sinkCount(x));
-    }
-
-    @Test
-    void sinkCount_twoReachableSinksDifferentBranches() {
-        /*
-         * Values:
-         *   s(8), t(6), u(5), v(7), w(3)
-         * Edges:
-         *   s -> t, u
-         *   t -> v
-         *   u -> (none)     // sink #1
-         *   v -> (none)     // sink #2
-         *   w -> (none)     // unreachable sink from s
-         *
-         * From s, reachable sinks: u, v  => 2
-         */
-        Vertex<Integer> s = new Vertex<>(8);
-        Vertex<Integer> t = new Vertex<>(6);
-        Vertex<Integer> u = new Vertex<>(5);
-        Vertex<Integer> v = new Vertex<>(7);
-        Vertex<Integer> w = new Vertex<>(3);
-
-        s.neighbors.add(t);
-        s.neighbors.add(u);
-        t.neighbors.add(v);
-        // u -> none
-        // v -> none
-        // w -> none (unreachable)
-
-        assertEquals(2, Practice.sinkCount(s));
-    }
+    // // ===== adults ============================================================
+
+    // @Test
+    // void adults_mixedAgesWithBoundaryIncluded() {
+    //     Map<String, Integer> ages = new HashMap<>();
+    //     ages.put("Ana", 17);
+    //     ages.put("Ben", 18);
+    //     ages.put("Caz", 41);
+    //     ages.put("Dee", 16);
+    //     ages.put("Eli", 18);
+
+    //     Set<String> result = Practice.adults(ages);
+    //     Set<String> expected = new HashSet<>(Arrays.asList("Ben", "Caz", "Eli"));
+
+    //     assertEquals(expected, result);
+    // }
+
+    // @Test
+    // void adults_emptyInputGivesEmptySet() {
+    //     Map<String, Integer> ages = new HashMap<>();
+    //     assertTrue(Practice.adults(ages).isEmpty());
+    // }
+
+    // @Test
+    // void adults_noAdultsAllUnder18() {
+    //     Map<String, Integer> ages = new HashMap<>();
+    //     ages.put("Ira", 6);
+    //     ages.put("Jay", 12);
+    //     ages.put("Kai", 17);
+    //     assertTrue(Practice.adults(ages).isEmpty());
+    // }
+
+    // // ===== biggestNumber =====================================================
+
+    // @Test
+    // void biggestNumber_mixedPosNegAndDuplicates() {
+    //     /*
+    //      * List:
+    //      *   5 -> -11 -> 42 -> 7 -> 42 -> -3 -> 0
+    //      */
+    //     ListNode<Integer> head = new ListNode<>(5,
+    //         new ListNode<>(-11,
+    //             new ListNode<>(42,
+    //                 new ListNode<>(7,
+    //                     new ListNode<>(42,
+    //                         new ListNode<>(-3,
+    //                             new ListNode<>(0, null)))))));
+
+    //     assertEquals(42, Practice.biggestNumber(head));
+    // }
+
+    // @Test
+    // void biggestNumber_singleNodeNegative() {
+    //     /*
+    //      * List:
+    //      *   -8
+    //      */
+    //     ListNode<Integer> head = new ListNode<>(-8, null);
+    //     assertEquals(-8, Practice.biggestNumber(head));
+    // }
+
+    // @Test
+    // void biggestNumber_allEqualValues() {
+    //     /*
+    //      * List:
+    //      *   13 -> 13 -> 13
+    //      */
+    //     ListNode<Integer> head = new ListNode<>(13,
+    //         new ListNode<>(13,
+    //             new ListNode<>(13, null)));
+    //     assertEquals(13, Practice.biggestNumber(head));
+    // }
+
+    // // ===== frequencies =======================================================
+
+    // @Test
+    // void frequencies_stringsExampleFromSpecPlusMore() {
+    //     /*
+    //      * List:
+    //      *   a -> x -> a -> a -> x -> y -> z -> y
+    //      * Expected: {a=3, x=2, y=2, z=1}
+    //      */
+    //     ListNode<String> head = new ListNode<>("a",
+    //         new ListNode<>("x",
+    //             new ListNode<>("a",
+    //                 new ListNode<>("a",
+    //                     new ListNode<>("x",
+    //                         new ListNode<>("y",
+    //                             new ListNode<>("z",
+    //                                 new ListNode<>("y", null))))))));
+
+    //     Map<String, Integer> expected = new HashMap<>();
+    //     expected.put("a", 3);
+    //     expected.put("x", 2);
+    //     expected.put("y", 2);
+    //     expected.put("z", 1);
+
+    //     assertEquals(expected, Practice.frequencies(head));
+    // }
+
+    // @Test
+    // void frequencies_integersArbitraryOrder() {
+    //     /*
+    //      * List:
+    //      *   7 -> 9 -> 7 -> 7 -> 10 -> 9 -> 10 -> 7 -> 10 -> 10 -> 10
+    //      * Expected: {7=4, 9=2, 10=5}
+    //      */
+    //     ListNode<Integer> head = new ListNode<>(7,
+    //         new ListNode<>(9,
+    //             new ListNode<>(7,
+    //                 new ListNode<>(7,
+    //                     new ListNode<>(10,
+    //                         new ListNode<>(9,
+    //                             new ListNode<>(10,
+    //                                 new ListNode<>(7,
+    //                                     new ListNode<>(10,
+    //                                         new ListNode<>(10,
+    //                                             new ListNode<>(10, null)))))))))));
+
+    //     Map<Integer, Integer> expected = new HashMap<>();
+    //     expected.put(7, 4);
+    //     expected.put(9, 2);
+    //     expected.put(10, 5);
+
+    //     assertEquals(expected, Practice.frequencies(head));
+    // }
+
+    // @Test
+    // void frequencies_nullHeadReturnsEmptyMap() {
+    //     ListNode<String> head = null;
+    //     assertTrue(Practice.frequencies(head).isEmpty());
+    // }
+
+    // // ===== levelCount ========================================================
+
+    // @Test
+    // void levelCount_nullRootIsZero() {
+    //     BinaryTreeNode<Integer> root = null;
+    //     assertEquals(0, Practice.levelCount(root));
+    // }
+
+    // @Test
+    // void levelCount_singleNodeIsOne() {
+    //     /*
+    //      *   42
+    //      */
+    //     BinaryTreeNode<Integer> root = new BinaryTreeNode<>(42);
+    //     assertEquals(1, Practice.levelCount(root));
+    // }
+
+    // @Test
+    // void levelCount_balancedThreeLevels() {
+    //     /*
+    //      *        8
+    //      *      /   \
+    //      *     3     10
+    //      *    / \      \
+    //      *   1   6      14
+    //      */
+    //     BinaryTreeNode<Integer> root =
+    //         new BinaryTreeNode<>(8,
+    //             new BinaryTreeNode<>(3,
+    //                 new BinaryTreeNode<>(1),
+    //                 new BinaryTreeNode<>(6)),
+    //             new BinaryTreeNode<>(10,
+    //                 null,
+    //                 new BinaryTreeNode<>(14)));
+    //     assertEquals(3, Practice.levelCount(root));
+    // }
+
+    // @Test
+    // void levelCount_unbalancedDeeperLeft() {
+    //     /*
+    //      *       5
+    //      *      /
+    //      *     4
+    //      *    /
+    //      *   3
+    //      *    \
+    //      *     2
+    //      *    /
+    //      *   1
+    //      */
+    //     BinaryTreeNode<Integer> root =
+    //         new BinaryTreeNode<>(5,
+    //             new BinaryTreeNode<>(4,
+    //                 new BinaryTreeNode<>(3,
+    //                     null,
+    //                     new BinaryTreeNode<>(2,
+    //                         new BinaryTreeNode<>(1),
+    //                         null)),
+    //                 null),
+    //             null);
+    //     assertEquals(5, Practice.levelCount(root));
+    // }
+
+    // // ===== sumAtLevel ========================================================
+
+    // @Test
+    // void sumAtLevel_exampleFromSpec_level3Is18() {
+    //     /*
+    //      *       5
+    //      *     /   \
+    //      *    8     4
+    //      *   / \   /
+    //      *  7  9  2
+    //      *    /
+    //      *   1
+    //      * Level 3 nodes: 7, 9, 2 -> sum = 18
+    //      */
+    //     BinaryTreeNode<Integer> root =
+    //         new BinaryTreeNode<>(5,
+    //             new BinaryTreeNode<>(8,
+    //                 new BinaryTreeNode<>(7),
+    //                 new BinaryTreeNode<>(9,
+    //                     new BinaryTreeNode<>(1),
+    //                     null)),
+    //             new BinaryTreeNode<>(4,
+    //                 new BinaryTreeNode<>(2),
+    //                 null));
+
+    //     assertEquals(18, Practice.sumAtLevel(root, 3));
+    // }
+
+    // @Test
+    // void sumAtLevel_level1IsRootValue() {
+    //     /*
+    //      *    12
+    //      *   /  \
+    //      *  7    5
+    //      */
+    //     BinaryTreeNode<Integer> root =
+    //         new BinaryTreeNode<>(12,
+    //             new BinaryTreeNode<>(7),
+    //             new BinaryTreeNode<>(5));
+
+    //     assertEquals(12, Practice.sumAtLevel(root, 1));
+    // }
+
+    // @Test
+    // void sumAtLevel_levelBeyondDepthIsZero() {
+    //     /*
+    //      *   9
+    //      *    \
+    //      *     2
+    //      */
+    //     BinaryTreeNode<Integer> root =
+    //         new BinaryTreeNode<>(9,
+    //             null,
+    //             new BinaryTreeNode<>(2));
+    //     assertEquals(0, Practice.sumAtLevel(root, 5));
+    // }
+
+    // @Test
+    // void sumAtLevel_levelZeroIsNotPresentSoZero() {
+    //     /*
+    //      *   3
+    //      */
+    //     BinaryTreeNode<Integer> root = new BinaryTreeNode<>(3);
+    //     assertEquals(0, Practice.sumAtLevel(root, 0));
+    // }
+
+    // @Test
+    // void sumAtLevel_emptyTreeIsZero() {
+    //     BinaryTreeNode<Integer> root = null;
+    //     assertEquals(0, Practice.sumAtLevel(root, 2));
+    // }
+
+    // // ===== sumMatch ==========================================================
+
+    // @Test
+    // void sumMatch_equalSumsNonEmpty() {
+    //     /*
+    //      * Tree:
+    //      *      6
+    //      *     / \
+    //      *    4   1
+    //      *   / \
+    //      *  -2  7
+    //      * Tree sum = 6 + 4 + 1 + (-2) + 7 = 16
+    //      *
+    //      * List:
+    //      *  10 -> 3 -> 3
+    //      * List sum = 16
+    //      */
+    //     BinaryTreeNode<Integer> root =
+    //         new BinaryTreeNode<>(6,
+    //             new BinaryTreeNode<>(4,
+    //                 new BinaryTreeNode<>(-2),
+    //                 new BinaryTreeNode<>(7)),
+    //             new BinaryTreeNode<>(1));
+
+    //     ListNode<Integer> head = new ListNode<>(10,
+    //         new ListNode<>(3,
+    //             new ListNode<>(3, null)));
+
+    //     assertTrue(Practice.sumMatch(root, head));
+    // }
+
+    // @Test
+    // void sumMatch_notEqual() {
+    //     /*
+    //      * Tree:
+    //      *    5
+    //      *   / \
+    //      *  2   2
+    //      * Sum = 9
+    //      *
+    //      * List:
+    //      *  4 -> 4
+    //      * Sum = 8
+    //      */
+    //     BinaryTreeNode<Integer> root =
+    //         new BinaryTreeNode<>(5,
+    //             new BinaryTreeNode<>(2),
+    //             new BinaryTreeNode<>(2));
+
+    //     ListNode<Integer> head = new ListNode<>(4,
+    //         new ListNode<>(4, null));
+
+    //     assertFalse(Practice.sumMatch(root, head));
+    // }
+
+    // @Test
+    // void sumMatch_bothEmptyAreZeroSoTrue() {
+    //     BinaryTreeNode<Integer> root = null;
+    //     ListNode<Integer> head = null;
+    //     assertTrue(Practice.sumMatch(root, head));
+    // }
+
+    // @Test
+    // void sumMatch_emptyTreeNonEmptyListFalse() {
+    //     BinaryTreeNode<Integer> root = null;
+    //     /*
+    //      * List:
+    //      *   1 -> 2
+    //      */
+    //     ListNode<Integer> head = new ListNode<>(1, new ListNode<>(2, null));
+    //     assertFalse(Practice.sumMatch(root, head));
+    // }
+
+    // // ===== graphSum & sinkCount (directed; neighbors = outgoing) =============
+
+    // @Test
+    // void graphSum_cyclicComponentPlusDetachedVertex() {
+    //     /*
+    //      * Vertices (values):
+    //      *   v1(5), v2(7), v3(-2), v4(10), v5(1), v6(3)
+    //      *
+    //      * Edges (directed), includes cycles:
+    //      *   v1 -> v2, v3
+    //      *   v2 -> v4
+    //      *   v3 -> v2, v5
+    //      *   v4 -> v1           // cycle v1 -> v2 -> v4 -> v1
+    //      *   v5 -> v3           // cycle v3 <-> v5
+    //      *   v6 -> (none)       // detached sink (not reachable from v1)
+    //      *
+    //      * From v1, reachable: {v1,v2,v3,v4,v5}
+    //      * Sum = 5 + 7 + (-2) + 10 + 1 = 21
+    //      */
+    //     Vertex<Integer> v1 = new Vertex<>(5);
+    //     Vertex<Integer> v2 = new Vertex<>(7);
+    //     Vertex<Integer> v3 = new Vertex<>(-2);
+    //     Vertex<Integer> v4 = new Vertex<>(10);
+    //     Vertex<Integer> v5 = new Vertex<>(1);
+    //     Vertex<Integer> v6 = new Vertex<>(3);
+
+    //     v1.neighbors.add(v2);
+    //     v1.neighbors.add(v3);
+
+    //     v2.neighbors.add(v4);
+
+    //     v3.neighbors.add(v2);
+    //     v3.neighbors.add(v5);
+
+    //     v4.neighbors.add(v1);
+
+    //     v5.neighbors.add(v3);
+
+    //     // v6 has no neighbors
+
+    //     assertEquals(21, Practice.graphSum(v1));
+    //     assertEquals(3, Practice.graphSum(v6));  // only itself
+    //     assertEquals(0, Practice.graphSum(null));
+    // }
+
+    // @Test
+    // void sinkCount_cyclicComponentWithOneReachableSinkAndOneUnreachableSink() {
+    //     /*
+    //      * Values:
+    //      *   a(10), b(4), c(7), d(2), e(9), f(4)
+    //      *
+    //      * Edges (directed):
+    //      *   a -> b, c
+    //      *   b -> d
+    //      *   c -> b, e
+    //      *   d -> a              // cycle a -> b -> d -> a
+    //      *   e -> c              // cycle c <-> e
+    //      *   f -> (none)         // unreachable sink from a
+    //      *
+    //      * Also add a reachable sink g(5):
+    //      *   g -> (none)
+    //      *   and connect c -> g
+    //      *
+    //      * From a, sinks reachable: only g
+    //      * So sinkCount(a) = 1
+    //      * From f, sinks reachable: f itself, so sinkCount(f) = 1
+    //      */
+    //     Vertex<Integer> a = new Vertex<>(10);
+    //     Vertex<Integer> b = new Vertex<>(4);
+    //     Vertex<Integer> c = new Vertex<>(7);
+    //     Vertex<Integer> d = new Vertex<>(2);
+    //     Vertex<Integer> e = new Vertex<>(9);
+    //     Vertex<Integer> f = new Vertex<>(4);
+    //     Vertex<Integer> g = new Vertex<>(5);
+
+    //     a.neighbors.add(b);
+    //     a.neighbors.add(c);
+
+    //     b.neighbors.add(d);
+
+    //     c.neighbors.add(b);
+    //     c.neighbors.add(e);
+
+    //     d.neighbors.add(a);
+
+    //     e.neighbors.add(c);
+
+    //     // f -> (none)
+    //     // g -> (none)
+    //     c.neighbors.add(g); // make g reachable from a via c
+
+    //     assertEquals(1, Practice.sinkCount(a)); // only g is sink and reachable
+    //     assertEquals(1, Practice.sinkCount(f)); // f is a sink by itself
+    // }
+
+    // @Test
+    // void sinkCount_cyclicNoSinksReachable() {
+    //     /*
+    //      * Values:
+    //      *   x(1), y(2), z(3)
+    //      * Edges:
+    //      *   x -> y
+    //      *   y -> z
+    //      *   z -> x   // 3-cycle, all outdegree > 0
+    //      * From x, there are no reachable sinks.
+    //      */
+    //     Vertex<Integer> x = new Vertex<>(1);
+    //     Vertex<Integer> y = new Vertex<>(2);
+    //     Vertex<Integer> z = new Vertex<>(3);
+
+    //     x.neighbors.add(y);
+    //     y.neighbors.add(z);
+    //     z.neighbors.add(x);
+
+    //     assertEquals(0, Practice.sinkCount(x));
+    // }
+
+    // @Test
+    // void sinkCount_twoReachableSinksDifferentBranches() {
+    //     /*
+    //      * Values:
+    //      *   s(8), t(6), u(5), v(7), w(3)
+    //      * Edges:
+    //      *   s -> t, u
+    //      *   t -> v
+    //      *   u -> (none)     // sink #1
+    //      *   v -> (none)     // sink #2
+    //      *   w -> (none)     // unreachable sink from s
+    //      *
+    //      * From s, reachable sinks: u, v  => 2
+    //      */
+    //     Vertex<Integer> s = new Vertex<>(8);
+    //     Vertex<Integer> t = new Vertex<>(6);
+    //     Vertex<Integer> u = new Vertex<>(5);
+    //     Vertex<Integer> v = new Vertex<>(7);
+    //     Vertex<Integer> w = new Vertex<>(3);
+
+    //     s.neighbors.add(t);
+    //     s.neighbors.add(u);
+    //     t.neighbors.add(v);
+    //     // u -> none
+    //     // v -> none
+    //     // w -> none (unreachable)
+
+    //     assertEquals(2, Practice.sinkCount(s));
+    // }
 }

From ce0fc2de96b61d26a70fe87811d295accc0fdae2 Mon Sep 17 00:00:00 2001
From: X BELL <194058603+bellxalli@users.noreply.github.com>
Date: Wed, 24 Sep 2025 16:47:34 -0700
Subject: [PATCH 02/10] added and completed adults method with all tests
 passing

---
 src/Practice.java     |  16 +++++-
 src/PracticeTest.java | 130 +++++++++++++++++++++---------------------
 2 files changed, 80 insertions(+), 66 deletions(-)

diff --git a/src/Practice.java b/src/Practice.java
index 5b8a602..2708984 100644
--- a/src/Practice.java
+++ b/src/Practice.java
@@ -80,7 +80,21 @@ else if(smallest.length() == word.length())
      * @throws NullPointerException if ages is null
      */
     public static Set<String> adults(Map<String, Integer> ages) {
-        return null;
+        if(ages == null)
+        {
+            throw new NullPointerException("map is null");
+        }
+        Set<String> names = new HashSet<>();
+
+        for(String name : ages.keySet())
+        {
+            if(ages.get(name) >= 18)
+            {
+                names.add(name);
+            }
+        }
+
+        return names;
     }
 
     /**
diff --git a/src/PracticeTest.java b/src/PracticeTest.java
index c629d79..9dc7713 100644
--- a/src/PracticeTest.java
+++ b/src/PracticeTest.java
@@ -60,78 +60,78 @@ void shortestWord_allSameLength() {
         assertEquals("ape", Practice.shortestWord(words));
     }
 
-    // // ===== adults ============================================================
+    // ===== adults ============================================================
 
-    // @Test
-    // void adults_mixedAgesWithBoundaryIncluded() {
-    //     Map<String, Integer> ages = new HashMap<>();
-    //     ages.put("Ana", 17);
-    //     ages.put("Ben", 18);
-    //     ages.put("Caz", 41);
-    //     ages.put("Dee", 16);
-    //     ages.put("Eli", 18);
-
-    //     Set<String> result = Practice.adults(ages);
-    //     Set<String> expected = new HashSet<>(Arrays.asList("Ben", "Caz", "Eli"));
-
-    //     assertEquals(expected, result);
-    // }
-
-    // @Test
-    // void adults_emptyInputGivesEmptySet() {
-    //     Map<String, Integer> ages = new HashMap<>();
-    //     assertTrue(Practice.adults(ages).isEmpty());
-    // }
+    @Test
+    void adults_mixedAgesWithBoundaryIncluded() {
+        Map<String, Integer> ages = new HashMap<>();
+        ages.put("Ana", 17);
+        ages.put("Ben", 18);
+        ages.put("Caz", 41);
+        ages.put("Dee", 16);
+        ages.put("Eli", 18);
+
+        Set<String> result = Practice.adults(ages);
+        Set<String> expected = new HashSet<>(Arrays.asList("Ben", "Caz", "Eli"));
+
+        assertEquals(expected, result);
+    }
 
-    // @Test
-    // void adults_noAdultsAllUnder18() {
-    //     Map<String, Integer> ages = new HashMap<>();
-    //     ages.put("Ira", 6);
-    //     ages.put("Jay", 12);
-    //     ages.put("Kai", 17);
-    //     assertTrue(Practice.adults(ages).isEmpty());
-    // }
+    @Test
+    void adults_emptyInputGivesEmptySet() {
+        Map<String, Integer> ages = new HashMap<>();
+        assertTrue(Practice.adults(ages).isEmpty());
+    }
 
-    // // ===== biggestNumber =====================================================
+    @Test
+    void adults_noAdultsAllUnder18() {
+        Map<String, Integer> ages = new HashMap<>();
+        ages.put("Ira", 6);
+        ages.put("Jay", 12);
+        ages.put("Kai", 17);
+        assertTrue(Practice.adults(ages).isEmpty());
+    }
 
-    // @Test
-    // void biggestNumber_mixedPosNegAndDuplicates() {
-    //     /*
-    //      * List:
-    //      *   5 -> -11 -> 42 -> 7 -> 42 -> -3 -> 0
-    //      */
-    //     ListNode<Integer> head = new ListNode<>(5,
-    //         new ListNode<>(-11,
-    //             new ListNode<>(42,
-    //                 new ListNode<>(7,
-    //                     new ListNode<>(42,
-    //                         new ListNode<>(-3,
-    //                             new ListNode<>(0, null)))))));
+    // ===== biggestNumber =====================================================
 
-    //     assertEquals(42, Practice.biggestNumber(head));
-    // }
+    @Test
+    void biggestNumber_mixedPosNegAndDuplicates() {
+        /*
+         * List:
+         *   5 -> -11 -> 42 -> 7 -> 42 -> -3 -> 0
+         */
+        ListNode<Integer> head = new ListNode<>(5,
+            new ListNode<>(-11,
+                new ListNode<>(42,
+                    new ListNode<>(7,
+                        new ListNode<>(42,
+                            new ListNode<>(-3,
+                                new ListNode<>(0, null)))))));
+
+        assertEquals(42, Practice.biggestNumber(head));
+    }
 
-    // @Test
-    // void biggestNumber_singleNodeNegative() {
-    //     /*
-    //      * List:
-    //      *   -8
-    //      */
-    //     ListNode<Integer> head = new ListNode<>(-8, null);
-    //     assertEquals(-8, Practice.biggestNumber(head));
-    // }
+    @Test
+    void biggestNumber_singleNodeNegative() {
+        /*
+         * List:
+         *   -8
+         */
+        ListNode<Integer> head = new ListNode<>(-8, null);
+        assertEquals(-8, Practice.biggestNumber(head));
+    }
 
-    // @Test
-    // void biggestNumber_allEqualValues() {
-    //     /*
-    //      * List:
-    //      *   13 -> 13 -> 13
-    //      */
-    //     ListNode<Integer> head = new ListNode<>(13,
-    //         new ListNode<>(13,
-    //             new ListNode<>(13, null)));
-    //     assertEquals(13, Practice.biggestNumber(head));
-    // }
+    @Test
+    void biggestNumber_allEqualValues() {
+        /*
+         * List:
+         *   13 -> 13 -> 13
+         */
+        ListNode<Integer> head = new ListNode<>(13,
+            new ListNode<>(13,
+                new ListNode<>(13, null)));
+        assertEquals(13, Practice.biggestNumber(head));
+    }
 
     // // ===== frequencies =======================================================
 

From d7f0d96ebb3dd49e1c731723380c38b069c93701 Mon Sep 17 00:00:00 2001
From: X BELL <194058603+bellxalli@users.noreply.github.com>
Date: Wed, 24 Sep 2025 17:01:32 -0700
Subject: [PATCH 03/10] completed biggestNumber method with all tests passing

---
 src/Practice.java | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/Practice.java b/src/Practice.java
index 2708984..212cc87 100644
--- a/src/Practice.java
+++ b/src/Practice.java
@@ -105,7 +105,24 @@ public static Set<String> adults(Map<String, Integer> ages) {
      * @throws IllegalArgumentException if head is null
      */
     public static int biggestNumber(ListNode<Integer> head) {
-        return 0;
+        if(head == null)
+        {
+            throw new IllegalArgumentException("head is null");
+        }
+
+        ListNode<Integer> current = head;
+        int biggest = head.data;
+
+        while(current.next != null)
+        {
+            if(current.data > biggest)
+            {
+                biggest = current.data;
+            }
+            current = current.next;
+        }
+
+        return biggest;
     }
 
     /**

From 564b875de699a03716ebc516ee9674bacf5a6aa1 Mon Sep 17 00:00:00 2001
From: X BELL <194058603+bellxalli@users.noreply.github.com>
Date: Wed, 24 Sep 2025 17:17:04 -0700
Subject: [PATCH 04/10] completed frequencies method and passed all tests

---
 src/Practice.java     |  24 ++++++++-
 src/PracticeTest.java | 112 +++++++++++++++++++++---------------------
 2 files changed, 79 insertions(+), 57 deletions(-)

diff --git a/src/Practice.java b/src/Practice.java
index 212cc87..d12e271 100644
--- a/src/Practice.java
+++ b/src/Practice.java
@@ -139,7 +139,29 @@ public static int biggestNumber(ListNode<Integer> head) {
      * @return a frequency map of values in the list
      */
     public static <T> Map<T, Integer> frequencies(ListNode<T> head) {
-        return null;
+        //go through list 
+        //add each new value from list as key in map with a value of 1
+        //if a value from list appears again increase the value for said key in map
+        //return the map
+
+        Map<T, Integer> frequencyMap = new HashMap<>();
+        ListNode<T> current = head;
+
+        while(current != null)
+        {
+            if(!frequencyMap.containsKey(current.data))
+            {
+                frequencyMap.put(current.data, 1);
+            }
+            else
+            {
+                frequencyMap.put(current.data, frequencyMap.get(current.data)+1);
+            }
+
+            current = current.next;
+        }
+
+        return frequencyMap;
     }
 
 
diff --git a/src/PracticeTest.java b/src/PracticeTest.java
index 9dc7713..9889c11 100644
--- a/src/PracticeTest.java
+++ b/src/PracticeTest.java
@@ -133,65 +133,65 @@ void biggestNumber_allEqualValues() {
         assertEquals(13, Practice.biggestNumber(head));
     }
 
-    // // ===== frequencies =======================================================
+    // ===== frequencies =======================================================
 
-    // @Test
-    // void frequencies_stringsExampleFromSpecPlusMore() {
-    //     /*
-    //      * List:
-    //      *   a -> x -> a -> a -> x -> y -> z -> y
-    //      * Expected: {a=3, x=2, y=2, z=1}
-    //      */
-    //     ListNode<String> head = new ListNode<>("a",
-    //         new ListNode<>("x",
-    //             new ListNode<>("a",
-    //                 new ListNode<>("a",
-    //                     new ListNode<>("x",
-    //                         new ListNode<>("y",
-    //                             new ListNode<>("z",
-    //                                 new ListNode<>("y", null))))))));
-
-    //     Map<String, Integer> expected = new HashMap<>();
-    //     expected.put("a", 3);
-    //     expected.put("x", 2);
-    //     expected.put("y", 2);
-    //     expected.put("z", 1);
-
-    //     assertEquals(expected, Practice.frequencies(head));
-    // }
+    @Test
+    void frequencies_stringsExampleFromSpecPlusMore() {
+        /*
+         * List:
+         *   a -> x -> a -> a -> x -> y -> z -> y
+         * Expected: {a=3, x=2, y=2, z=1}
+         */
+        ListNode<String> head = new ListNode<>("a",
+            new ListNode<>("x",
+                new ListNode<>("a",
+                    new ListNode<>("a",
+                        new ListNode<>("x",
+                            new ListNode<>("y",
+                                new ListNode<>("z",
+                                    new ListNode<>("y", null))))))));
+
+        Map<String, Integer> expected = new HashMap<>();
+        expected.put("a", 3);
+        expected.put("x", 2);
+        expected.put("y", 2);
+        expected.put("z", 1);
+
+        assertEquals(expected, Practice.frequencies(head));
+    }
 
-    // @Test
-    // void frequencies_integersArbitraryOrder() {
-    //     /*
-    //      * List:
-    //      *   7 -> 9 -> 7 -> 7 -> 10 -> 9 -> 10 -> 7 -> 10 -> 10 -> 10
-    //      * Expected: {7=4, 9=2, 10=5}
-    //      */
-    //     ListNode<Integer> head = new ListNode<>(7,
-    //         new ListNode<>(9,
-    //             new ListNode<>(7,
-    //                 new ListNode<>(7,
-    //                     new ListNode<>(10,
-    //                         new ListNode<>(9,
-    //                             new ListNode<>(10,
-    //                                 new ListNode<>(7,
-    //                                     new ListNode<>(10,
-    //                                         new ListNode<>(10,
-    //                                             new ListNode<>(10, null)))))))))));
-
-    //     Map<Integer, Integer> expected = new HashMap<>();
-    //     expected.put(7, 4);
-    //     expected.put(9, 2);
-    //     expected.put(10, 5);
-
-    //     assertEquals(expected, Practice.frequencies(head));
-    // }
+    @Test
+    void frequencies_integersArbitraryOrder() {
+        /*
+         * List:
+         *   7 -> 9 -> 7 -> 7 -> 10 -> 9 -> 10 -> 7 -> 10 -> 10 -> 10
+         * Expected: {7=4, 9=2, 10=5}
+         */
+        ListNode<Integer> head = new ListNode<>(7,
+            new ListNode<>(9,
+                new ListNode<>(7,
+                    new ListNode<>(7,
+                        new ListNode<>(10,
+                            new ListNode<>(9,
+                                new ListNode<>(10,
+                                    new ListNode<>(7,
+                                        new ListNode<>(10,
+                                            new ListNode<>(10,
+                                                new ListNode<>(10, null)))))))))));
+
+        Map<Integer, Integer> expected = new HashMap<>();
+        expected.put(7, 4);
+        expected.put(9, 2);
+        expected.put(10, 5);
+
+        assertEquals(expected, Practice.frequencies(head));
+    }
 
-    // @Test
-    // void frequencies_nullHeadReturnsEmptyMap() {
-    //     ListNode<String> head = null;
-    //     assertTrue(Practice.frequencies(head).isEmpty());
-    // }
+    @Test
+    void frequencies_nullHeadReturnsEmptyMap() {
+        ListNode<String> head = null;
+        assertTrue(Practice.frequencies(head).isEmpty());
+    }
 
     // // ===== levelCount ========================================================
 

From 977ee789dafc3c5507148d12df78d7a38100fe49 Mon Sep 17 00:00:00 2001
From: X BELL <194058603+bellxalli@users.noreply.github.com>
Date: Wed, 24 Sep 2025 22:36:16 -0700
Subject: [PATCH 05/10] completed levelCount method and passed all tests

---
 src/Practice.java     |  17 ++++++-
 src/PracticeTest.java | 116 +++++++++++++++++++++---------------------
 2 files changed, 74 insertions(+), 59 deletions(-)

diff --git a/src/Practice.java b/src/Practice.java
index d12e271..7ba68dd 100644
--- a/src/Practice.java
+++ b/src/Practice.java
@@ -174,7 +174,22 @@ public static <T> Map<T, Integer> frequencies(ListNode<T> head) {
      * @return the number of levels in the tree
      */
     public static int levelCount(BinaryTreeNode<?> root) {
-        return 0;
+        if(root == null)
+        {
+            return 0;
+        }
+        
+        int left = levelCount(root.left);
+        int right = levelCount(root.right);
+
+        if(left > right)
+        {
+            return left + 1;
+        }
+        else
+        {
+            return right + 1;
+        }
     }
 
 
diff --git a/src/PracticeTest.java b/src/PracticeTest.java
index 9889c11..2fc7a33 100644
--- a/src/PracticeTest.java
+++ b/src/PracticeTest.java
@@ -193,68 +193,68 @@ void frequencies_nullHeadReturnsEmptyMap() {
         assertTrue(Practice.frequencies(head).isEmpty());
     }
 
-    // // ===== levelCount ========================================================
+    // ===== levelCount ========================================================
 
-    // @Test
-    // void levelCount_nullRootIsZero() {
-    //     BinaryTreeNode<Integer> root = null;
-    //     assertEquals(0, Practice.levelCount(root));
-    // }
+    @Test
+    void levelCount_nullRootIsZero() {
+        BinaryTreeNode<Integer> root = null;
+        assertEquals(0, Practice.levelCount(root));
+    }
 
-    // @Test
-    // void levelCount_singleNodeIsOne() {
-    //     /*
-    //      *   42
-    //      */
-    //     BinaryTreeNode<Integer> root = new BinaryTreeNode<>(42);
-    //     assertEquals(1, Practice.levelCount(root));
-    // }
+    @Test
+    void levelCount_singleNodeIsOne() {
+        /*
+         *   42
+         */
+        BinaryTreeNode<Integer> root = new BinaryTreeNode<>(42);
+        assertEquals(1, Practice.levelCount(root));
+    }
 
-    // @Test
-    // void levelCount_balancedThreeLevels() {
-    //     /*
-    //      *        8
-    //      *      /   \
-    //      *     3     10
-    //      *    / \      \
-    //      *   1   6      14
-    //      */
-    //     BinaryTreeNode<Integer> root =
-    //         new BinaryTreeNode<>(8,
-    //             new BinaryTreeNode<>(3,
-    //                 new BinaryTreeNode<>(1),
-    //                 new BinaryTreeNode<>(6)),
-    //             new BinaryTreeNode<>(10,
-    //                 null,
-    //                 new BinaryTreeNode<>(14)));
-    //     assertEquals(3, Practice.levelCount(root));
-    // }
+    @Test
+    void levelCount_balancedThreeLevels() {
+        /*
+         *        8
+         *      /   \
+         *     3     10
+         *    / \      \
+         *   1   6      14
+         */
+        BinaryTreeNode<Integer> root =
+            new BinaryTreeNode<>(8,
+                new BinaryTreeNode<>(3,
+                    new BinaryTreeNode<>(1),
+                    new BinaryTreeNode<>(6)),
+                new BinaryTreeNode<>(10,
+                    null,
+                    new BinaryTreeNode<>(14)));
+        assertEquals(3, Practice.levelCount(root));
+    }
 
-    // @Test
-    // void levelCount_unbalancedDeeperLeft() {
-    //     /*
-    //      *       5
-    //      *      /
-    //      *     4
-    //      *    /
-    //      *   3
-    //      *    \
-    //      *     2
-    //      *    /
-    //      *   1
-    //      */
-    //     BinaryTreeNode<Integer> root =
-    //         new BinaryTreeNode<>(5,
-    //             new BinaryTreeNode<>(4,
-    //                 new BinaryTreeNode<>(3,
-    //                     null,
-    //                     new BinaryTreeNode<>(2,
-    //                         new BinaryTreeNode<>(1),
-    //                         null)),
-    //                 null),
-    //             null);
-    //     assertEquals(5, Practice.levelCount(root));
-    // }
+    @Test
+    void levelCount_unbalancedDeeperLeft() {
+        /*
+         *       5
+         *      /
+         *     4
+         *    /
+         *   3
+         *    \
+         *     2
+         *    /
+         *   1
+         */
+        BinaryTreeNode<Integer> root =
+            new BinaryTreeNode<>(5,
+                new BinaryTreeNode<>(4,
+                    new BinaryTreeNode<>(3,
+                        null,
+                        new BinaryTreeNode<>(2,
+                            new BinaryTreeNode<>(1),
+                            null)),
+                    null),
+                null);
+        assertEquals(5, Practice.levelCount(root));
+    }
 
     // // ===== sumAtLevel ========================================================
 

From a0f2d583f6427fc0196ef48f7c1c9b8c9ff99f69 Mon Sep 17 00:00:00 2001
From: X BELL <194058603+bellxalli@users.noreply.github.com>
Date: Wed, 24 Sep 2025 22:42:18 -0700
Subject: [PATCH 06/10] completed sumatlevel method and passed all tests

---
 src/Practice.java     |  19 +++++--
 src/PracticeTest.java | 128 +++++++++++++++++++++---------------------
 2 files changed, 79 insertions(+), 68 deletions(-)

diff --git a/src/Practice.java b/src/Practice.java
index 7ba68dd..b7533af 100644
--- a/src/Practice.java
+++ b/src/Practice.java
@@ -164,7 +164,6 @@ public static <T> Map<T, Integer> frequencies(ListNode<T> head) {
         return frequencyMap;
     }
 
-
     /**
      * Returns the number of levels in the tree.
      * 
@@ -178,7 +177,7 @@ public static int levelCount(BinaryTreeNode<?> root) {
         {
             return 0;
         }
-        
+
         int left = levelCount(root.left);
         int right = levelCount(root.right);
 
@@ -217,9 +216,21 @@ public static int levelCount(BinaryTreeNode<?> root) {
      * @return the sum of the nodes at the given level
      */
     public static int sumAtLevel(BinaryTreeNode<Integer> root, int level) {
-        return 0;
-    }
+        if(root == null || level < 1)
+        {
+            return 0;
+        }
+
+        if(level == 1)
+        {
+            return root.data;
+        }
+
+        int left = sumAtLevel(root.left, level - 1);
+        int right = sumAtLevel(root.right, level - 1);
 
+        return left + right;
+    }
 
     /**
      * Returns true if the sum of the values in a given tree is equal to the sum
diff --git a/src/PracticeTest.java b/src/PracticeTest.java
index 2fc7a33..057575e 100644
--- a/src/PracticeTest.java
+++ b/src/PracticeTest.java
@@ -256,77 +256,77 @@ void levelCount_unbalancedDeeperLeft() {
         assertEquals(5, Practice.levelCount(root));
     }
 
-    // // ===== sumAtLevel ========================================================
+    // ===== sumAtLevel ========================================================
 
-    // @Test
-    // void sumAtLevel_exampleFromSpec_level3Is18() {
-    //     /*
-    //      *       5
-    //      *     /   \
-    //      *    8     4
-    //      *   / \   /
-    //      *  7  9  2
-    //      *    /
-    //      *   1
-    //      * Level 3 nodes: 7, 9, 2 -> sum = 18
-    //      */
-    //     BinaryTreeNode<Integer> root =
-    //         new BinaryTreeNode<>(5,
-    //             new BinaryTreeNode<>(8,
-    //                 new BinaryTreeNode<>(7),
-    //                 new BinaryTreeNode<>(9,
-    //                     new BinaryTreeNode<>(1),
-    //                     null)),
-    //             new BinaryTreeNode<>(4,
-    //                 new BinaryTreeNode<>(2),
-    //                 null));
+    @Test
+    void sumAtLevel_exampleFromSpec_level3Is18() {
+        /*
+         *       5
+         *     /   \
+         *    8     4
+         *   / \   /
+         *  7  9  2
+         *    /
+         *   1
+         * Level 3 nodes: 7, 9, 2 -> sum = 18
+         */
+        BinaryTreeNode<Integer> root =
+            new BinaryTreeNode<>(5,
+                new BinaryTreeNode<>(8,
+                    new BinaryTreeNode<>(7),
+                    new BinaryTreeNode<>(9,
+                        new BinaryTreeNode<>(1),
+                        null)),
+                new BinaryTreeNode<>(4,
+                    new BinaryTreeNode<>(2),
+                    null));
 
-    //     assertEquals(18, Practice.sumAtLevel(root, 3));
-    // }
+        assertEquals(18, Practice.sumAtLevel(root, 3));
+    }
 
-    // @Test
-    // void sumAtLevel_level1IsRootValue() {
-    //     /*
-    //      *    12
-    //      *   /  \
-    //      *  7    5
-    //      */
-    //     BinaryTreeNode<Integer> root =
-    //         new BinaryTreeNode<>(12,
-    //             new BinaryTreeNode<>(7),
-    //             new BinaryTreeNode<>(5));
+    @Test
+    void sumAtLevel_level1IsRootValue() {
+        /*
+         *    12
+         *   /  \
+         *  7    5
+         */
+        BinaryTreeNode<Integer> root =
+            new BinaryTreeNode<>(12,
+                new BinaryTreeNode<>(7),
+                new BinaryTreeNode<>(5));
 
-    //     assertEquals(12, Practice.sumAtLevel(root, 1));
-    // }
+        assertEquals(12, Practice.sumAtLevel(root, 1));
+    }
 
-    // @Test
-    // void sumAtLevel_levelBeyondDepthIsZero() {
-    //     /*
-    //      *   9
-    //      *    \
-    //      *     2
-    //      */
-    //     BinaryTreeNode<Integer> root =
-    //         new BinaryTreeNode<>(9,
-    //             null,
-    //             new BinaryTreeNode<>(2));
-    //     assertEquals(0, Practice.sumAtLevel(root, 5));
-    // }
+    @Test
+    void sumAtLevel_levelBeyondDepthIsZero() {
+        /*
+         *   9
+         *    \
+         *     2
+         */
+        BinaryTreeNode<Integer> root =
+            new BinaryTreeNode<>(9,
+                null,
+                new BinaryTreeNode<>(2));
+        assertEquals(0, Practice.sumAtLevel(root, 5));
+    }
 
-    // @Test
-    // void sumAtLevel_levelZeroIsNotPresentSoZero() {
-    //     /*
-    //      *   3
-    //      */
-    //     BinaryTreeNode<Integer> root = new BinaryTreeNode<>(3);
-    //     assertEquals(0, Practice.sumAtLevel(root, 0));
-    // }
+    @Test
+    void sumAtLevel_levelZeroIsNotPresentSoZero() {
+        /*
+         *   3
+         */
+        BinaryTreeNode<Integer> root = new BinaryTreeNode<>(3);
+        assertEquals(0, Practice.sumAtLevel(root, 0));
+    }
 
-    // @Test
-    // void sumAtLevel_emptyTreeIsZero() {
-    //     BinaryTreeNode<Integer> root = null;
-    //     assertEquals(0, Practice.sumAtLevel(root, 2));
-    // }
+    @Test
+    void sumAtLevel_emptyTreeIsZero() {
+        BinaryTreeNode<Integer> root = null;
+        assertEquals(0, Practice.sumAtLevel(root, 2));
+    }
 
     // // ===== sumMatch ==========================================================
 

From 215b0d056eb41815050fc7ee78a177e110058381 Mon Sep 17 00:00:00 2001
From: X BELL <194058603+bellxalli@users.noreply.github.com>
Date: Wed, 24 Sep 2025 23:00:02 -0700
Subject: [PATCH 07/10] completed sumMatch and passed all tests

---
 src/Practice.java     |  32 +++++++++-
 src/PracticeTest.java | 132 +++++++++++++++++++++---------------------
 2 files changed, 96 insertions(+), 68 deletions(-)

diff --git a/src/Practice.java b/src/Practice.java
index b7533af..0281634 100644
--- a/src/Practice.java
+++ b/src/Practice.java
@@ -191,7 +191,6 @@ public static int levelCount(BinaryTreeNode<?> root) {
         }
     }
 
-
     /**
      * Returns the sum at a specified level in a binary tree.
      * 
@@ -243,7 +242,36 @@ public static int sumAtLevel(BinaryTreeNode<Integer> root, int level) {
      * @return true if the sums are equal, false otherwise
      */
     public static boolean sumMatch(BinaryTreeNode<Integer> root, ListNode<Integer> head) {
-        return false;
+        if(root == null && head == null)
+        {
+            return true;
+        }
+        else if((root == null && head != null) || (root != null && head == null))
+        {
+            return false;
+        }
+
+        int treeSum = treeSum(root);
+
+        int listSum = 0;
+        ListNode<Integer> current = head;
+        
+        while(current != null)
+        {
+            listSum += current.data;
+            current = current.next;
+        }
+
+        return listSum == treeSum;   
+    }
+    public static int treeSum(BinaryTreeNode<Integer> root)
+    {
+        if(root == null)
+        {
+            return 0;
+        }
+        int sum = root.data + treeSum(root.left) + treeSum(root.right);
+        return sum;
     }
 
     /**
diff --git a/src/PracticeTest.java b/src/PracticeTest.java
index 057575e..98e21e9 100644
--- a/src/PracticeTest.java
+++ b/src/PracticeTest.java
@@ -328,78 +328,78 @@ void sumAtLevel_emptyTreeIsZero() {
         assertEquals(0, Practice.sumAtLevel(root, 2));
     }
 
-    // // ===== sumMatch ==========================================================
+    // ===== sumMatch ==========================================================
 
-    // @Test
-    // void sumMatch_equalSumsNonEmpty() {
-    //     /*
-    //      * Tree:
-    //      *      6
-    //      *     / \
-    //      *    4   1
-    //      *   / \
-    //      *  -2  7
-    //      * Tree sum = 6 + 4 + 1 + (-2) + 7 = 16
-    //      *
-    //      * List:
-    //      *  10 -> 3 -> 3
-    //      * List sum = 16
-    //      */
-    //     BinaryTreeNode<Integer> root =
-    //         new BinaryTreeNode<>(6,
-    //             new BinaryTreeNode<>(4,
-    //                 new BinaryTreeNode<>(-2),
-    //                 new BinaryTreeNode<>(7)),
-    //             new BinaryTreeNode<>(1));
-
-    //     ListNode<Integer> head = new ListNode<>(10,
-    //         new ListNode<>(3,
-    //             new ListNode<>(3, null)));
-
-    //     assertTrue(Practice.sumMatch(root, head));
-    // }
+    @Test
+    void sumMatch_equalSumsNonEmpty() {
+        /*
+         * Tree:
+         *      6
+         *     / \
+         *    4   1
+         *   / \
+         *  -2  7
+         * Tree sum = 6 + 4 + 1 + (-2) + 7 = 16
+         *
+         * List:
+         *  10 -> 3 -> 3
+         * List sum = 16
+         */
+        BinaryTreeNode<Integer> root =
+            new BinaryTreeNode<>(6,
+                new BinaryTreeNode<>(4,
+                    new BinaryTreeNode<>(-2),
+                    new BinaryTreeNode<>(7)),
+                new BinaryTreeNode<>(1));
 
-    // @Test
-    // void sumMatch_notEqual() {
-    //     /*
-    //      * Tree:
-    //      *    5
-    //      *   / \
-    //      *  2   2
-    //      * Sum = 9
-    //      *
-    //      * List:
-    //      *  4 -> 4
-    //      * Sum = 8
-    //      */
-    //     BinaryTreeNode<Integer> root =
-    //         new BinaryTreeNode<>(5,
-    //             new BinaryTreeNode<>(2),
-    //             new BinaryTreeNode<>(2));
+        ListNode<Integer> head = new ListNode<>(10,
+            new ListNode<>(3,
+                new ListNode<>(3, null)));
 
-    //     ListNode<Integer> head = new ListNode<>(4,
-    //         new ListNode<>(4, null));
+        assertTrue(Practice.sumMatch(root, head));
+    }
 
-    //     assertFalse(Practice.sumMatch(root, head));
-    // }
+    @Test
+    void sumMatch_notEqual() {
+        /*
+         * Tree:
+         *    5
+         *   / \
+         *  2   2
+         * Sum = 9
+         *
+         * List:
+         *  4 -> 4
+         * Sum = 8
+         */
+        BinaryTreeNode<Integer> root =
+            new BinaryTreeNode<>(5,
+                new BinaryTreeNode<>(2),
+                new BinaryTreeNode<>(2));
 
-    // @Test
-    // void sumMatch_bothEmptyAreZeroSoTrue() {
-    //     BinaryTreeNode<Integer> root = null;
-    //     ListNode<Integer> head = null;
-    //     assertTrue(Practice.sumMatch(root, head));
-    // }
+        ListNode<Integer> head = new ListNode<>(4,
+            new ListNode<>(4, null));
 
-    // @Test
-    // void sumMatch_emptyTreeNonEmptyListFalse() {
-    //     BinaryTreeNode<Integer> root = null;
-    //     /*
-    //      * List:
-    //      *   1 -> 2
-    //      */
-    //     ListNode<Integer> head = new ListNode<>(1, new ListNode<>(2, null));
-    //     assertFalse(Practice.sumMatch(root, head));
-    // }
+        assertFalse(Practice.sumMatch(root, head));
+    }
+
+    @Test
+    void sumMatch_bothEmptyAreZeroSoTrue() {
+        BinaryTreeNode<Integer> root = null;
+        ListNode<Integer> head = null;
+        assertTrue(Practice.sumMatch(root, head));
+    }
+
+    @Test
+    void sumMatch_emptyTreeNonEmptyListFalse() {
+        BinaryTreeNode<Integer> root = null;
+        /*
+         * List:
+         *   1 -> 2
+         */
+        ListNode<Integer> head = new ListNode<>(1, new ListNode<>(2, null));
+        assertFalse(Practice.sumMatch(root, head));
+    }
 
     // // ===== graphSum & sinkCount (directed; neighbors = outgoing) =============
 

From 15ee7adffdc33203942d5bec319a5d2c39edcab9 Mon Sep 17 00:00:00 2001
From: X BELL <194058603+bellxalli@users.noreply.github.com>
Date: Wed, 24 Sep 2025 23:07:23 -0700
Subject: [PATCH 08/10] completed graphSum method and passed all tests

---
 src/Practice.java     |  25 +++-
 src/PracticeTest.java | 292 +++++++++++++++++++++---------------------
 2 files changed, 170 insertions(+), 147 deletions(-)

diff --git a/src/Practice.java b/src/Practice.java
index 0281634..891989a 100644
--- a/src/Practice.java
+++ b/src/Practice.java
@@ -270,6 +270,7 @@ public static int treeSum(BinaryTreeNode<Integer> root)
         {
             return 0;
         }
+        
         int sum = root.data + treeSum(root.left) + treeSum(root.right);
         return sum;
     }
@@ -284,7 +285,29 @@ public static int treeSum(BinaryTreeNode<Integer> root)
      * @return the sum of all the vertices
      */
     public static int graphSum(Vertex<Integer> start) {
-        return 0;
+        if(start == null)
+        {
+            return 0;
+        }
+        Set<Vertex<Integer>> visited = new HashSet<>();
+        return sumGraph(start, visited);
+    }
+    public static int sumGraph(Vertex<Integer> vert, Set<Vertex<Integer>> visited)
+    {
+        if(visited.contains(vert))
+        {
+            return 0;
+        }
+
+        visited.add(vert);
+        int sum = vert.data;
+
+        for(Vertex<Integer> n : vert.neighbors)
+        {
+            sum += sumGraph(n, visited);
+        }
+
+        return sum;
     }
 
     /**
diff --git a/src/PracticeTest.java b/src/PracticeTest.java
index 98e21e9..8081e24 100644
--- a/src/PracticeTest.java
+++ b/src/PracticeTest.java
@@ -401,150 +401,150 @@ void sumMatch_emptyTreeNonEmptyListFalse() {
         assertFalse(Practice.sumMatch(root, head));
     }
 
-    // // ===== graphSum & sinkCount (directed; neighbors = outgoing) =============
-
-    // @Test
-    // void graphSum_cyclicComponentPlusDetachedVertex() {
-    //     /*
-    //      * Vertices (values):
-    //      *   v1(5), v2(7), v3(-2), v4(10), v5(1), v6(3)
-    //      *
-    //      * Edges (directed), includes cycles:
-    //      *   v1 -> v2, v3
-    //      *   v2 -> v4
-    //      *   v3 -> v2, v5
-    //      *   v4 -> v1           // cycle v1 -> v2 -> v4 -> v1
-    //      *   v5 -> v3           // cycle v3 <-> v5
-    //      *   v6 -> (none)       // detached sink (not reachable from v1)
-    //      *
-    //      * From v1, reachable: {v1,v2,v3,v4,v5}
-    //      * Sum = 5 + 7 + (-2) + 10 + 1 = 21
-    //      */
-    //     Vertex<Integer> v1 = new Vertex<>(5);
-    //     Vertex<Integer> v2 = new Vertex<>(7);
-    //     Vertex<Integer> v3 = new Vertex<>(-2);
-    //     Vertex<Integer> v4 = new Vertex<>(10);
-    //     Vertex<Integer> v5 = new Vertex<>(1);
-    //     Vertex<Integer> v6 = new Vertex<>(3);
-
-    //     v1.neighbors.add(v2);
-    //     v1.neighbors.add(v3);
-
-    //     v2.neighbors.add(v4);
-
-    //     v3.neighbors.add(v2);
-    //     v3.neighbors.add(v5);
-
-    //     v4.neighbors.add(v1);
-
-    //     v5.neighbors.add(v3);
-
-    //     // v6 has no neighbors
-
-    //     assertEquals(21, Practice.graphSum(v1));
-    //     assertEquals(3, Practice.graphSum(v6));  // only itself
-    //     assertEquals(0, Practice.graphSum(null));
-    // }
-
-    // @Test
-    // void sinkCount_cyclicComponentWithOneReachableSinkAndOneUnreachableSink() {
-    //     /*
-    //      * Values:
-    //      *   a(10), b(4), c(7), d(2), e(9), f(4)
-    //      *
-    //      * Edges (directed):
-    //      *   a -> b, c
-    //      *   b -> d
-    //      *   c -> b, e
-    //      *   d -> a              // cycle a -> b -> d -> a
-    //      *   e -> c              // cycle c <-> e
-    //      *   f -> (none)         // unreachable sink from a
-    //      *
-    //      * Also add a reachable sink g(5):
-    //      *   g -> (none)
-    //      *   and connect c -> g
-    //      *
-    //      * From a, sinks reachable: only g
-    //      * So sinkCount(a) = 1
-    //      * From f, sinks reachable: f itself, so sinkCount(f) = 1
-    //      */
-    //     Vertex<Integer> a = new Vertex<>(10);
-    //     Vertex<Integer> b = new Vertex<>(4);
-    //     Vertex<Integer> c = new Vertex<>(7);
-    //     Vertex<Integer> d = new Vertex<>(2);
-    //     Vertex<Integer> e = new Vertex<>(9);
-    //     Vertex<Integer> f = new Vertex<>(4);
-    //     Vertex<Integer> g = new Vertex<>(5);
-
-    //     a.neighbors.add(b);
-    //     a.neighbors.add(c);
-
-    //     b.neighbors.add(d);
-
-    //     c.neighbors.add(b);
-    //     c.neighbors.add(e);
-
-    //     d.neighbors.add(a);
-
-    //     e.neighbors.add(c);
-
-    //     // f -> (none)
-    //     // g -> (none)
-    //     c.neighbors.add(g); // make g reachable from a via c
-
-    //     assertEquals(1, Practice.sinkCount(a)); // only g is sink and reachable
-    //     assertEquals(1, Practice.sinkCount(f)); // f is a sink by itself
-    // }
-
-    // @Test
-    // void sinkCount_cyclicNoSinksReachable() {
-    //     /*
-    //      * Values:
-    //      *   x(1), y(2), z(3)
-    //      * Edges:
-    //      *   x -> y
-    //      *   y -> z
-    //      *   z -> x   // 3-cycle, all outdegree > 0
-    //      * From x, there are no reachable sinks.
-    //      */
-    //     Vertex<Integer> x = new Vertex<>(1);
-    //     Vertex<Integer> y = new Vertex<>(2);
-    //     Vertex<Integer> z = new Vertex<>(3);
-
-    //     x.neighbors.add(y);
-    //     y.neighbors.add(z);
-    //     z.neighbors.add(x);
-
-    //     assertEquals(0, Practice.sinkCount(x));
-    // }
-
-    // @Test
-    // void sinkCount_twoReachableSinksDifferentBranches() {
-    //     /*
-    //      * Values:
-    //      *   s(8), t(6), u(5), v(7), w(3)
-    //      * Edges:
-    //      *   s -> t, u
-    //      *   t -> v
-    //      *   u -> (none)     // sink #1
-    //      *   v -> (none)     // sink #2
-    //      *   w -> (none)     // unreachable sink from s
-    //      *
-    //      * From s, reachable sinks: u, v  => 2
-    //      */
-    //     Vertex<Integer> s = new Vertex<>(8);
-    //     Vertex<Integer> t = new Vertex<>(6);
-    //     Vertex<Integer> u = new Vertex<>(5);
-    //     Vertex<Integer> v = new Vertex<>(7);
-    //     Vertex<Integer> w = new Vertex<>(3);
-
-    //     s.neighbors.add(t);
-    //     s.neighbors.add(u);
-    //     t.neighbors.add(v);
-    //     // u -> none
-    //     // v -> none
-    //     // w -> none (unreachable)
-
-    //     assertEquals(2, Practice.sinkCount(s));
-    // }
+    // ===== graphSum & sinkCount (directed; neighbors = outgoing) =============
+
+    @Test
+    void graphSum_cyclicComponentPlusDetachedVertex() {
+        /*
+         * Vertices (values):
+         *   v1(5), v2(7), v3(-2), v4(10), v5(1), v6(3)
+         *
+         * Edges (directed), includes cycles:
+         *   v1 -> v2, v3
+         *   v2 -> v4
+         *   v3 -> v2, v5
+         *   v4 -> v1           // cycle v1 -> v2 -> v4 -> v1
+         *   v5 -> v3           // cycle v3 <-> v5
+         *   v6 -> (none)       // detached sink (not reachable from v1)
+         *
+         * From v1, reachable: {v1,v2,v3,v4,v5}
+         * Sum = 5 + 7 + (-2) + 10 + 1 = 21
+         */
+        Vertex<Integer> v1 = new Vertex<>(5);
+        Vertex<Integer> v2 = new Vertex<>(7);
+        Vertex<Integer> v3 = new Vertex<>(-2);
+        Vertex<Integer> v4 = new Vertex<>(10);
+        Vertex<Integer> v5 = new Vertex<>(1);
+        Vertex<Integer> v6 = new Vertex<>(3);
+
+        v1.neighbors.add(v2);
+        v1.neighbors.add(v3);
+
+        v2.neighbors.add(v4);
+
+        v3.neighbors.add(v2);
+        v3.neighbors.add(v5);
+
+        v4.neighbors.add(v1);
+
+        v5.neighbors.add(v3);
+
+        // v6 has no neighbors
+
+        assertEquals(21, Practice.graphSum(v1));
+        assertEquals(3, Practice.graphSum(v6));  // only itself
+        assertEquals(0, Practice.graphSum(null));
+    }
+
+    @Test
+    void sinkCount_cyclicComponentWithOneReachableSinkAndOneUnreachableSink() {
+        /*
+         * Values:
+         *   a(10), b(4), c(7), d(2), e(9), f(4)
+         *
+         * Edges (directed):
+         *   a -> b, c
+         *   b -> d
+         *   c -> b, e
+         *   d -> a              // cycle a -> b -> d -> a
+         *   e -> c              // cycle c <-> e
+         *   f -> (none)         // unreachable sink from a
+         *
+         * Also add a reachable sink g(5):
+         *   g -> (none)
+         *   and connect c -> g
+         *
+         * From a, sinks reachable: only g
+         * So sinkCount(a) = 1
+         * From f, sinks reachable: f itself, so sinkCount(f) = 1
+         */
+        Vertex<Integer> a = new Vertex<>(10);
+        Vertex<Integer> b = new Vertex<>(4);
+        Vertex<Integer> c = new Vertex<>(7);
+        Vertex<Integer> d = new Vertex<>(2);
+        Vertex<Integer> e = new Vertex<>(9);
+        Vertex<Integer> f = new Vertex<>(4);
+        Vertex<Integer> g = new Vertex<>(5);
+
+        a.neighbors.add(b);
+        a.neighbors.add(c);
+
+        b.neighbors.add(d);
+
+        c.neighbors.add(b);
+        c.neighbors.add(e);
+
+        d.neighbors.add(a);
+
+        e.neighbors.add(c);
+
+        // f -> (none)
+        // g -> (none)
+        c.neighbors.add(g); // make g reachable from a via c
+
+        assertEquals(1, Practice.sinkCount(a)); // only g is sink and reachable
+        assertEquals(1, Practice.sinkCount(f)); // f is a sink by itself
+    }
+
+    @Test
+    void sinkCount_cyclicNoSinksReachable() {
+        /*
+         * Values:
+         *   x(1), y(2), z(3)
+         * Edges:
+         *   x -> y
+         *   y -> z
+         *   z -> x   // 3-cycle, all outdegree > 0
+         * From x, there are no reachable sinks.
+         */
+        Vertex<Integer> x = new Vertex<>(1);
+        Vertex<Integer> y = new Vertex<>(2);
+        Vertex<Integer> z = new Vertex<>(3);
+
+        x.neighbors.add(y);
+        y.neighbors.add(z);
+        z.neighbors.add(x);
+
+        assertEquals(0, Practice.sinkCount(x));
+    }
+
+    @Test
+    void sinkCount_twoReachableSinksDifferentBranches() {
+        /*
+         * Values:
+         *   s(8), t(6), u(5), v(7), w(3)
+         * Edges:
+         *   s -> t, u
+         *   t -> v
+         *   u -> (none)     // sink #1
+         *   v -> (none)     // sink #2
+         *   w -> (none)     // unreachable sink from s
+         *
+         * From s, reachable sinks: u, v  => 2
+         */
+        Vertex<Integer> s = new Vertex<>(8);
+        Vertex<Integer> t = new Vertex<>(6);
+        Vertex<Integer> u = new Vertex<>(5);
+        Vertex<Integer> v = new Vertex<>(7);
+        Vertex<Integer> w = new Vertex<>(3);
+
+        s.neighbors.add(t);
+        s.neighbors.add(u);
+        t.neighbors.add(v);
+        // u -> none
+        // v -> none
+        // w -> none (unreachable)
+
+        assertEquals(2, Practice.sinkCount(s));
+    }
 }

From 4de9b4183886ce9ebef8b92c9dcb1fb24fe18087 Mon Sep 17 00:00:00 2001
From: X BELL <194058603+bellxalli@users.noreply.github.com>
Date: Wed, 24 Sep 2025 23:13:26 -0700
Subject: [PATCH 09/10] completed sinkCount and passed all tests

---
 src/Practice.java | 31 ++++++++++++++++++++++++++++++-
 1 file changed, 30 insertions(+), 1 deletion(-)

diff --git a/src/Practice.java b/src/Practice.java
index 891989a..93324f7 100644
--- a/src/Practice.java
+++ b/src/Practice.java
@@ -319,6 +319,35 @@ public static int sumGraph(Vertex<Integer> vert, Set<Vertex<Integer>> visited)
      * @return the count of vertices with outdegree 0
      */
     public static int sinkCount(Vertex<Integer> start) {
-        return 0;
+        if(start == null)
+        {
+            return 0;
+        }
+
+        Set<Vertex<Integer>> visited = new HashSet<>();
+        return countOutDegrees(start, visited);
+    }
+    public static int countOutDegrees(Vertex<Integer> vert, Set<Vertex<Integer>> visited)
+    {
+        if(visited.contains(vert))
+        {
+            return 0;
+        }
+
+        visited.add(vert);
+
+        if(vert.neighbors == null || vert.neighbors.isEmpty()) //base case no neighbors
+        {
+            return 1; 
+        }
+
+        int count = 0;
+
+        for(Vertex<Integer> n : vert.neighbors)
+        {
+            count += countOutDegrees(n, visited);
+        }
+        
+        return count;
     }
 }
\ No newline at end of file

From 6f6da23c1bc3f5f607277101a4f272d62e699a93 Mon Sep 17 00:00:00 2001
From: X BELL <194058603+bellxalli@users.noreply.github.com>
Date: Wed, 24 Sep 2025 23:15:08 -0700
Subject: [PATCH 10/10] did final check for methods and tests ensuring all
 passed and they did

---
 src/Practice.java | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/Practice.java b/src/Practice.java
index 93324f7..d643c78 100644
--- a/src/Practice.java
+++ b/src/Practice.java
@@ -1,5 +1,3 @@
-// import java.util.Map;
-// import java.util.Set;
 import java.util.*;
 
 public class Practice {