Add files via upload

Author: 3LENDERMAN

05/__pycache__/ib111.cpython-311.pyc

@@ -0,0 +1,87 @@
+from ib111 import week_05  # noqa
+
+
+# System of attendance in company. Each employee has to swipe with card
+# at the entrance and same when leaving.
+
+# Sensor at the door evidates the records. Each record consists of employee id, 
+# time stamp and type of record (leaving, entrance) 
+
+EmployeeId = str  # employee id
+TimeStamp = int  # number of seconds from specific time
+RecordType = bool  # type of record
+
+ENTRY = True
+LEAVE = False
+
+MachineRecord = tuple[EmployeeId, TimeStamp, RecordType]
+
+# ‹employees_with_missing_records› returns set of employees who has some discrepancy
+# either came to work and never left or came many times without leaving.
+# Consider input list to be sorted by time stamps.
+
+def employees_with_missing_records(records: list[MachineRecord]) -> set[EmployeeId]:
+    temp_lst: list[tuple[str, bool | None]] = []
+    missing: set[str] = set()
+    if len(records) == 0: return missing
+    temp_dic: dict[str, bool | None] = dict(temp_lst)
+    for ids, data, rec in records:
+        if ids not in temp_dic and rec != None:
+            if rec: temp_dic[ids] = rec
+            else: 
+                temp_dic[ids] = None
+                missing.add(ids)
+        else:
+            if temp_dic[ids] != rec: temp_dic[ids] = rec
+            else: 
+                temp_dic[ids] = None
+                missing.add(ids)
+    return missing
+
+def main() -> None: # tests
+    id1 = "abc00001"
+    id2 = "xyz00002"
+    id3 = "hjkl0003"
+
+    e1 = (id1, 100, ENTRY)
+    e2 = (id2, 110, ENTRY)
+    e3 = (id3, 140, ENTRY)
+    e4 = (id1, 200, ENTRY)
+    e5 = (id1, 300, ENTRY)
+
+    l1 = (id1, 150, LEAVE)
+    l2 = (id2, 160, LEAVE)
+    l3 = (id3, 210, LEAVE)
+    l4 = (id1, 250, LEAVE)
+    l5 = (id2, 270, LEAVE)
+
+    # no missing records
+    m1 = employees_with_missing_records([])
+    assert len(m1) == 0
+
+    m2 = employees_with_missing_records([e1, l1])
+    assert len(m2) == 0
+
+    m3 = employees_with_missing_records([e1, e2, l1, l2, e4])
+    assert len(m3) == 0
+
+    m4 = employees_with_missing_records([e1, e3, l1, e4, l3, l4])
+    assert len(m4) == 0
+
+    # missing records
+    m5 = employees_with_missing_records([e1, l1, e4, e5])
+    assert len(m5) == 1
+    assert id1 in m5
+
+    m6 = employees_with_missing_records([e1, e2, l1, l2, l5])
+    assert len(m6) == 1
+    assert id2 in m6
+
+    m7 = employees_with_missing_records([e1, e4, l5])
+    assert len(m7) == 2
+    assert id1 in m7
+    assert id2 in m7
+
+
+if __name__ == "__main__":
+    main()

05/attendance.py

@@ -0,0 +1,89 @@
+from ib111 import week_05  # noqa
+
+# Color is represented by triple RGB (red,green,blue) in interval 0-255
+# Function <nearest_colour> returns colour from dictionary that is closest to <colour> 
+# parameter, if there are more colors in the same distance, return them all
+#
+# Proximity of colors will be measured by Manhattan distance,
+# sum of absolute values of A - B so of cords. Example:
+#
+#     A = (150, 0, 65)
+#     B = (120, 30, 100)
+#
+# Manhattan distance equales
+#
+#    |150 - 120| + |0 - 30| + |65 - 100| = 30 + 30 + 35 = 95
+
+
+Colour = tuple[int, int, int]
+
+
+def nearest_colour(names: dict[str, Colour],
+                   colour: Colour) -> set[str]:
+    closest_colors: set[str] = set()
+    col_name: str = ""
+    red,green,blue = colour
+    dist: int = 1000
+    for name, (r,g,b) in names.items():
+        x = (abs(r - red) + abs(g - green) + abs(b - blue))
+        if x < dist:
+            dist = x
+            col_name = name
+
+    closest_colors.add(col_name)
+    for name, (r,g,b) in names.items():
+        x = (abs(r - red) + abs(g - green) + abs(b - blue))
+        if x == dist:
+            col_name = name
+            closest_colors.add(col_name)
+    return closest_colors
+
+
+def main() -> None: # run tests
+    names = {
+        'black': (0, 0, 0),
+        'white': (255, 255, 255),
+        'red': (255, 0, 0),
+        'green': (0, 255, 0),
+        'blue': (0, 0, 255),
+        'yellow': (255, 255, 0),
+        'purple': (128, 0, 128),
+        'cyan': (0, 255, 255),
+        'magenta': (255, 0, 255),
+        'lime': (50, 205, 50),
+        'pink': (255, 192, 203),
+        'teal': (0, 128, 128),
+        'lavender': (230, 230, 250),
+        'maroon': (128, 0, 0),
+        'navy': (0, 0, 128),
+        'olive': (128, 128, 0),
+        'silver': (192, 192, 192),
+        'grey': (128, 128, 128),
+        'orange': (255, 165, 0),
+        'brown': (165, 42, 42),
+        'fuchsia': (255, 0, 255),
+        'violet': (238, 130, 238),
+        'indigo': (75, 0, 130),
+        'gold': (255, 215, 0),
+        'peachpuff': (255, 218, 185),
+        'darkorange': (255, 140, 0),
+        'chartreuse': (127, 255, 0),
+        'lightpink': (255, 182, 193),
+        'skyblue': (135, 206, 235),
+        'darkgreen': (0, 100, 0),
+    }
+
+    rgb = {
+        'red': (255, 0, 0),
+        'green': (0, 255, 0),
+        'blue': (0, 0, 255)
+    }
+
+    assert nearest_colour(names, (1, 1, 1)) == {'black'}
+    assert nearest_colour(names, (254, 254, 254)) == {'white'}
+    assert nearest_colour(rgb, (1, 1, 1)) == \
+        {'red', 'green', 'blue'}
+
+
+if __name__ == "__main__":
+    main()

05/colours.py

@@ -0,0 +1,49 @@
+from ib111 import week_05  # noqa
+
+# Student grades for a single course are stored in a dictionary, where
+# the key is the student's UČO and the value is the grade specified as a letter.
+# Possible grades are 'A' to 'F', then 'N', 'P', 'X', 'Z' and '-'.
+
+# ‹modus›, takes a dictionary of tokens and outputs their mode, i.e. the most frequent value.
+# If the input dictionary is empty, the output will be an empty set.
+
+def modus(marks: dict[int, str]) -> set[str]:
+    most_frequent: set[str] = set()
+    if len(marks) == 0: return most_frequent
+    highest = 0
+    count: dict[str,int] = {'A': 0, 'B': 0, 'C': 0, 'D': 0, 'E': 0, 'F': 0, 'N': 0, 'P': 0, 'X': 0, 'Z': 0, '-': 0}
+    for uco, mark in marks.items():
+        count[mark] += 1
+        if count[mark] > highest: highest = count[mark]
+    for grade, n in count.items():
+        if n == highest: most_frequent.add(grade)
+    return most_frequent
+
+# Predicate ‹check› checks if grades are in right format: 
+# (grades 'A' - 'F', or 'X'), (grades 'P', 'N'), (grades 'Z', 'N') or '-'
+
+def check(marks: dict[int, str]) -> bool:
+    #right_grades: set[str] = set()
+    right_grades: set[str] = {'A', 'B', 'C', 'D', 'E', 'F', 'P', 'X', 'Z', '-'}
+    for _, grade in marks.items():
+        if grade not in right_grades: return False
+    return True
+
+
+def main() -> None: #run tests
+    assert modus({}) == set()
+    assert modus({100000: 'P'}) == {'P'}
+    assert modus({100000: 'A', 100001: 'B', 100002: 'A'}) == {'A'}
+    assert modus({100000: 'A', 100001: 'B', 100002: 'A', 100003: 'B'}) \
+           == {'A', 'B'}
+    assert check({})
+    assert check({100000: 'P'})
+    assert check({100000: '-'})
+    assert check({100000: 'A', 100001: 'B', 100002: 'A'})
+    assert check({100000: 'A', 100001: 'B', 100002: 'A', 100003: 'B'})
+    assert not check({100000: 'A', 100001: 'B', 100002: 'A', 100003: 'N'})
+    assert not check({100000: 'P', 100001: 'N', 100002: 'Z', 100003: '-'})
+
+
+if __name__ == "__main__":
+    main()