feat: oct9 level 1

python/oct9/level1/bothLists.py

···
+from typing import List
+
+
+def inBothLists(L: List[int], M: List[int]) -> List[int]:
+    """Returns a list of unique elements that are present in both L and M."""
+    return list({x for x in L if x in M})
+
+
+def testInBothLists():
+    print("Testing inBothLists()...", end="")
+    assert inBothLists([1, 2, 3], [3, 2, 4]) == [2, 3]
+    assert inBothLists([3, 2, 1], [4, 1, 2, 1]) == [1, 2]
+    assert inBothLists([3, 2, 1, 2], [2, 2, 2]) == [2]
+    assert inBothLists([1, 2, 3], [4, 5, 6, 1]) == [1]
+    assert inBothLists([3, 2, 1, 2], [4]) == []
+
+    # Verify that the function is nonmutating:
+    L = [1, 2, 3]
+    M = [3, 2, 4]
+    inBothLists(L, M)
+    assert L == [1, 2, 3] and M == [3, 2, 4]
+    print("Passed!")
+
+
+def main():
+    testInBothLists()
+
+
+main()

python/oct9/level1/hasNoDuplicates.py

···
+from typing import List
+
+
+def hasNoDuplicates(L: List[int]) -> bool:
+    """Returns True if the list has no duplicates, False otherwise."""
+    return len(set(L)) == len(L)
+
+
+def testHasNoDuplicates():
+    print("Testing hasNoDuplicates()...", end="")
+    assert hasNoDuplicates([1, 2, 3, 2]) == False
+    assert hasNoDuplicates([1, 2, 3, 4]) == True
+    assert hasNoDuplicates([]) == True
+    assert hasNoDuplicates([42]) == True
+    assert hasNoDuplicates([42, 42]) == False
+
+    # Verify that the function is nonmutating:
+    L = [1, 2, 3, 2]
+    hasNoDuplicates(L)
+    assert L == [1, 2, 3, 2]
+    print("Passed!")
+
+
+def main():
+    testHasNoDuplicates()
+
+
+main()

python/oct9/level1/isPermutation.py

···
+from typing import List
+
+
+def isPermutation(L: List[int]) -> bool:
+    """Returns True if L is a permutation of the integers from 0 to len(L)-1."""
+    return sorted(L) == list(range(len(L)))
+
+
+def testIsPermutation():
+    print("Testing isPermutation()...", end="")
+    assert isPermutation([0, 2, 1, 4, 3]) == True
+    assert isPermutation([1, 3, 0, 4, 2]) == True
+    assert isPermutation([1, 3, 5, 4, 2]) == False
+    assert isPermutation([1, 4, 0, 4, 2]) == False
+
+    # Verify that the function is nonmutating:
+    L = [0, 2, 1, 4, 3]
+    isPermutation(L)
+    assert L == [0, 2, 1, 4, 3]
+    print("Passed!")
+
+
+def main():
+    testIsPermutation()
+
+
+main()

python/oct9/level1/movieAwards.py

···
+from typing import Set, Tuple, Dict
+
+
+def movieAwards(oscarResults: Set[Tuple[str, str]]) -> Dict[str, int]:
+    """Returns a dictionary mapping movie titles to the number of awards they won."""
+    awards_count = {}
+    for _, movie in oscarResults:
+        awards_count[movie] = awards_count.get(movie, 0) + 1
+    return awards_count
+
+
+def testMovieAwards():
+    print("Testing movieAwards()...", end="")
+    test = {
+        ("Best Picture", "The Shape of Water"),
+        ("Best Actor", "Darkest Hour"),
+        ("Best Actress", "Three Billboards Outside Ebbing, Missouri"),
+        ("Best Director", "The Shape of Water"),
+    }
+    result = {
+        "Darkest Hour": 1,
+        "Three Billboards Outside Ebbing, Missouri": 1,
+        "The Shape of Water": 2,
+    }
+    assert movieAwards(test) == result
+
+    test = {
+        ("Best Picture", "Moonlight"),
+        ("Best Director", "La La Land"),
+        ("Best Actor", "Manchester by the Sea"),
+        ("Best Actress", "La La Land"),
+    }
+    result = {"Moonlight": 1, "La La Land": 2, "Manchester by the Sea": 1}
+    assert movieAwards(test) == result
+
+    test = {
+        ("Best Picture", "12 Years a Slave"),
+        ("Best Director", "Gravity"),
+        ("Best Actor", "Dallas Buyers Club"),
+        ("Best Actress", "Blue Jasmine"),
+    }
+    result = {
+        "12 Years a Slave": 1,
+        "Gravity": 1,
+        "Dallas Buyers Club": 1,
+        "Blue Jasmine": 1,
+    }
+    assert movieAwards(test) == result
+
+    test = {
+        ("Best Picture", "The King's Speech"),
+        ("Best Director", "The King's Speech"),
+        ("Best Actor", "The King's Speech"),
+    }
+    result = {"The King's Speech": 3}
+    assert movieAwards(test) == result
+
+    test = {
+        ("Best Picture", "Spotlight"),
+        ("Best Director", "The Revenant"),
+        ("Best Actor", "The Revenant"),
+        ("Best Actress", "Room"),
+        ("Best Supporting Actor", "Bridge of Spies"),
+        ("Best Supporting Actress", "The Danish Girl"),
+        ("Best Original Screenplay", "Spotlight"),
+        ("Best Adapted Screenplay", "The Big Short"),
+        ("Best Production Design", "Mad Max: Fury Road"),
+        ("Best Cinematography", "The Revenant"),
+    }
+    result = {
+        "Spotlight": 2,
+        "The Revenant": 3,
+        "Room": 1,
+        "Bridge of Spies": 1,
+        "The Danish Girl": 1,
+        "The Big Short": 1,
+        "Mad Max: Fury Road": 1,
+    }
+    assert movieAwards(test) == result
+
+    assert movieAwards(set()) == dict()
+    print("Passed!")
+
+
+def main():
+    testMovieAwards()
+
+
+main()

python/oct9/level1/repeats.py

···
+from typing import List
+
+
+def repeats(L: List[int]) -> List[int]:
+    """Returns a sorted list of unique elements that are present in L more than once."""
+    return list(sorted({x for x in L if L.count(x) > 1}))
+
+
+def testRepeats():
+    print("Testing repeats()...", end="")
+    assert repeats([1, 2, 3, 2, 1]) == [1, 2]
+    assert repeats([1, 2, 3, 2, 2, 4]) == [2]
+    assert repeats([1, 5, 3, 5, 2, 3, 2, 1]) == [1, 2, 3, 5]
+    assert repeats([7, 9, 1, 3, 7, 1]) == [1, 7]
+    assert repeats(list(range(100))) == []
+    assert repeats(list(range(100)) * 5) == list(range(100))
+
+    # Verify that the function is nonmutating:
+    L = [1, 2, 3, 2, 1]
+    repeats(L)
+    assert L == [1, 2, 3, 2, 1]
+    print("Passed!")
+
+
+def main():
+    testRepeats()
+
+
+main()