feat: oct 8 level 1

python/oct8/level1/insertRowAndCol.py

···
+from typing import List
+
+
+def mutatingInsertRowAndCol(L: List[List[int]], row: int, col: int, val: int):
+    """Inserts a row and column into a matrix."""
+    L.insert(row, [val] * len(L[0]))
+    for i in range(len(L)):
+        L[i].insert(col, val)
+
+
+def nonmutatingInsertRowAndCol(
+    L: List[List[int]], row: int, col: int, val: int
+) -> List[List[int]]:
+    """Inserts a row and column into a matrix without mutating the original matrix."""
+    new_list = [[v for v in l] for l in L]
+
+    new_list.insert(row, [val] * len(new_list[0]))
+    for i in range(len(new_list)):
+        new_list[i].insert(col, val)
+
+    return new_list
+
+
+def testMutatingInsertRowAndCol():
+    print("Testing mutatingInsertRowAndCol()...", end="")
+    L = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
+    mutatingInsertRowAndCol(L, 1, 2, 42)
+    assert L == [
+        [1, 2, 42, 3, 4],
+        [42, 42, 42, 42, 42],
+        [5, 6, 42, 7, 8],
+        [9, 10, 42, 11, 12],
+    ]
+
+    L = [[1, 2, 3], [4, 5, 6]]
+    mutatingInsertRowAndCol(L, 0, 0, 5)
+    assert L == [[5, 5, 5, 5], [5, 1, 2, 3], [5, 4, 5, 6]]
+
+    L = [[1, 2, 3], [4, 5, 6]]
+    mutatingInsertRowAndCol(L, 1, 3, 5)
+    assert L == [[1, 2, 3, 5], [5, 5, 5, 5], [4, 5, 6, 5]]
+
+
+def testNonmutatingInsertRowAndCol():
+    print("Testing nonmutatingInsertRowAndCol()...", end="")
+    L = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
+    assert nonmutatingInsertRowAndCol(L, 1, 2, 42) == [
+        [1, 2, 42, 3, 4],
+        [42, 42, 42, 42, 42],
+        [5, 6, 42, 7, 8],
+        [9, 10, 42, 11, 12],
+    ]
+
+    L = [[1, 2, 3], [4, 5, 6]]
+    assert nonmutatingInsertRowAndCol(L, 0, 0, 5) == [
+        [5, 5, 5, 5],
+        [5, 1, 2, 3],
+        [5, 4, 5, 6],
+    ]
+
+    L = [[1, 2, 3], [4, 5, 6]]
+    assert nonmutatingInsertRowAndCol(L, 1, 3, 5) == [
+        [1, 2, 3, 5],
+        [5, 5, 5, 5],
+        [4, 5, 6, 5],
+    ]
+
+    # Verify that the function is non-mutating
+    L = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
+    nonmutatingInsertRowAndCol(L, 1, 2, 42)
+    assert L == [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
+    print("Passed!")
+
+
+def main():
+    testMutatingInsertRowAndCol()
+    testNonmutatingInsertRowAndCol()
+
+
+main()

python/oct8/level1/isRectangular.py

···
+from typing import List
+
+
+def isRectangular(L: List[List[int]]) -> bool:
+    """Check if the length of each row is equal to the length of the first row."""
+    return all(len(row) == len(L[0]) for row in L)
+
+
+def testIsRectangular():
+    print("Testing isRectangular()...", end="")
+    L = [[1, 2, 3], [4, 5, 6]]
+    assert isRectangular(L) == True
+    L = [[1, 2], [4, 5, 6]]
+    assert isRectangular(L) == False
+    L = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
+    assert isRectangular(L) == True
+    print("Passed!")
+
+
+def main():
+    testIsRectangular()
+
+
+main()

python/oct8/level1/largestColumnSum.py

···
+from typing import List
+
+
+def largestColumnSum(L: List[List[int]]) -> int:
+    """Return the largest sum of any column in the matrix."""
+    cols = [sum(col) for col in zip(*L)]
+    return max(cols)
+
+
+def testLargestColumnSum():
+    print("Testing largestColumnSum()...", end="")
+    L = [[1, 2, 3], [4, 5, 6]]
+    assert largestColumnSum(L) == 9  # sum([3, 6])
+
+    L = [[3, 2, 1], [-5, -3, -6]]
+    assert largestColumnSum(L) == -1  # sum([2, -3])
+
+    L = [[1, 2, 3], [4, 5, 6], [7, -1, -2]]
+    assert largestColumnSum(L) == 12  # sum([1, 4, 7])
+
+    L = [[7, -1, -2]]
+    assert largestColumnSum(L) == 7  # sum([7])
+    print("Passed!")
+
+
+def main():
+    testLargestColumnSum()
+
+
+main()