Add 3 more challenges

Author: Shehab Abdel-Salam

ninja_challenges/exercises/challenge_16.py

@@ -0,0 +1,22 @@
+# Challenge 16 - Word Search
+# Write a function that takes a 2D matrix of letters and a word
+# and returns True if the word is present in the matrix.
+
+# The word can be constructed from letters of sequentially adjacent cell,
+# where "adjacent" cells are those horizontally or vertically neighboring.
+# The same letter cell may not be used more than once.
+
+# Example:
+# Given the following matrix:
+# [
+#     ['A', 'B', 'C', 'E'],
+#     ['S', 'F', 'C', 'S'],
+#     ['A', 'D', 'E', 'E'],
+# ]
+#
+# word_search(matrix, "ABCCED") -> True
+# word_search(matrix, "SEE") -> True
+# word_search(matrix, "ABCB") -> False
+
+
+def is_word_in_matrix(matrix: list[list[str]], word: str) -> bool: ...

ninja_challenges/exercises/challenge_17.py

@@ -0,0 +1,15 @@
+# Challenge 17 - Compare Version Numbers
+# Write a function that compares two version numbers version1 and version2.
+# To compare version numbers, compare their components in left-to-right order.
+# Components are separated by a dot '.' and each component may contain
+# multiple digits. Every component contains non-negative integers except
+# for the first component. The first component is a non-negative integer
+# and the rest of the components are separated by a dot '.'.
+# For example, 2.5.33 and 0.1 are valid version numbers.
+# To compare version numbers:
+# If version1 > version2 return 1,
+# If version1 < version2 return -1,
+# Otherwise return 0.
+
+
+def compare_versions(version1: str, version2: str) -> int: ...

ninja_challenges/exercises/challenge_18.py

@@ -0,0 +1,20 @@
+# Challenge 18 - Flatten Nested List Iterator
+# Write an iterator that will flatten a nested list of integers.
+# The iterator should have two methods:
+# next() and hasNext().
+#
+# For example, given the following nested list:
+# [
+#     1,
+#     [4, [6]]
+# ]
+#
+# The iterator should return 1, 4, 6.
+
+
+class NestedIterator:
+    def __init__(self, nested_list: list[list[int]]): ...
+
+    def next(self) -> int: ...
+
+    def hasNext(self) -> bool: ...

ninja_challenges/tests/test_ninja_challenges.py

@@ -13,6 +13,9 @@
 from ..exercises.challenge_13 import is_monotonic
 from ..exercises.challenge_14 import add_matrices
 from ..exercises.challenge_15 import transpose_matrix
+from ..exercises.challenge_16 import is_word_in_matrix
+from ..exercises.challenge_17 import compare_versions
+from ..exercises.challenge_18 import NestedIterator
 
 
 def test_challenge_01():
@@ -75,3 +78,80 @@ def test_challenge_14():
 
 def test_challenge_15():
     assert transpose_matrix([]) == []
+
+
+def test_challenge_16():
+    assert is_word_in_matrix([], "") is False
+    assert (
+        is_word_in_matrix(
+            [["A", "B", "C", "E"], ["S", "F", "C", "S"], ["A", "D", "E", "E"]], "ABCCED"
+        )
+        is True
+    )
+    assert (
+        is_word_in_matrix(
+            [["A", "B", "C", "E"], ["S", "F", "C", "S"], ["A", "D", "E", "E"]], "SEE"
+        )
+        is True
+    )
+    assert (
+        is_word_in_matrix(
+            [["A", "B", "C", "E"], ["S", "F", "C", "S"], ["A", "D", "E", "E"]], "ABCB"
+        )
+        is False
+    )
+    assert (
+        is_word_in_matrix(
+            [["A", "B", "C", "E"], ["S", "F", "C", "S"], ["A", "D", "E", "E"]],
+            "ABCESEEDAS",
+        )
+        is True
+    )
+    assert (
+        is_word_in_matrix(
+            [["A", "B", "C", "E"], ["S", "F", "C", "S"], ["A", "D", "E", "E"]],
+            "ABCESEDAS",
+        )
+        is False
+    )
+
+
+def test_challenge_17():
+    assert compare_versions("1.01", "1.001") == 0
+    assert compare_versions("1.0", "1.0.0") == 0
+    assert compare_versions("0.1", "1.1") == -1
+    assert compare_versions("1.0.1", "1") == 1
+    assert compare_versions("1.0.1", "1.0.10") == -1
+    assert compare_versions("1.0.1", "1.0.1") == 0
+    assert compare_versions("1.0.1", "1.0.2") == -1
+    assert compare_versions("1.0.1", "1.0.0") == 1
+
+
+def test_challenge_18():
+    iterator0 = NestedIterator([[1, [2, [3, [4]]]]])
+    assert iterator0.next() == 1
+    assert iterator0.next() == 2
+    assert iterator0.next() == 3
+    assert iterator0.next() == 4
+    assert iterator0.hasNext() is False
+
+    iterator1 = NestedIterator([[1, 2], [3], [4, 5, 6]])
+    assert iterator1.next() == 1
+    assert iterator1.next() == 2
+    assert iterator1.next() == 3
+    assert iterator1.next() == 4
+    assert iterator1.next() == 5
+    assert iterator1.next() == 6
+    assert iterator1.hasNext() is False
+
+    iterator2 = NestedIterator([[1, 2, 3], [4, [5, 6]], [7, 8, 9]])
+    assert iterator2.next() == 1
+    assert iterator2.next() == 2
+    assert iterator2.next() == 3
+    assert iterator2.next() == 4
+    assert iterator2.next() == 5
+    assert iterator2.next() == 6
+    assert iterator2.next() == 7
+    assert iterator2.next() == 8
+    assert iterator2.next() == 9
+    assert iterator2.hasNext() is False