feat: oct 10 level 0

python/oct10/level0/odometer.py

···
+from typing import List, Optional
+
+
+class Odometer:
+    """An odometer where all digits must be in ascending order"""
+
+    miles: int
+
+    @staticmethod
+    def _is_error(miles: int) -> bool:
+        """Return True if the given miles are not in ascending order or contain a zero."""
+        try:
+            Odometer(miles)
+        except ValueError:
+            return True
+        return False
+
+    @staticmethod
+    def possible_values(odo_len: int) -> List[int]:
+        """Return a list of possible values for the given miles."""
+        min = Odometer._get_minimum(odo_len)
+        max = Odometer._get_maximum(odo_len)
+        return [i for i in range(min, max + 1) if not Odometer._is_error(i)]
+
+    @staticmethod
+    def _ascending(digits: List[int]) -> bool:
+        return all(digits[i] < digits[i + 1] for i in range(len(digits) - 1))
+
+    @staticmethod
+    def _get_digits(miles: int) -> List[int]:
+        """Return a list of digits from the given miles."""
+        return list(map(int, str(miles)))
+
+    @staticmethod
+    def _verify_miles(miles: int) -> None:
+        """Verify that the given miles are in ascending order and do not contain a zero. Throws ValueError if not."""
+        digits = Odometer._get_digits(miles)
+        if len(digits) > 9:
+            raise ValueError("Miles cannot be greater than 9 digits")
+        if not Odometer._ascending(digits):
+            raise ValueError("Miles must be in ascending order")
+        if any(d == 0 for d in digits):
+            raise ValueError("Miles cannot contain a zero")
+
+    @staticmethod
+    def _get_maximum(odo_len: int) -> int:
+        """Return the maximum possible miles given the current odometer length."""
+        return int("".join([str(i) for i in range(10 - odo_len, 10)]))
+
+    @staticmethod
+    def _get_minimum(odo_len: int) -> int:
+        """Return the minimum possible miles given the current odometer length."""
+        return int("".join([str(i) for i in range(1, odo_len + 1)]))
+
+    def __init__(self, starting_miles: int = 1) -> None:
+        """Initialize an odometer with the given starting miles."""
+        if starting_miles < 0:
+            raise ValueError("Starting miles cannot be negative")
+        Odometer._verify_miles(starting_miles)
+        self.miles = starting_miles
+
+
+    def verify_miles(self) -> bool:
+        """Verify that the odometer's miles are in ascending order and do not contain a zero."""
+        try:
+            Odometer._verify_miles(self.miles)
+        except ValueError:
+            return False
+        return True
+
+    def get_digits(self) -> List[int]:
+        """Return the odometer's miles as a list of digits."""
+        return list(map(int, str(self.miles)))
+
+    def get_minimum(self) -> int:
+        """Return the minimum valid odometer reading."""
+        return Odometer._get_minimum(len(self.get_digits()))
+
+    def get_maximum(self) -> int:
+        """Return the maximum valid odometer reading."""
+        return Odometer._get_maximum(len(self.get_digits()))
+
+    def next_reading(self) -> Optional[int]:
+        """Return the next valid odometer reading."""
+        first_run = True
+        if self.miles == self.get_maximum():
+            return None
+        while not self.verify_miles() or first_run:
+            first_run = False
+            self.miles += 1
+        return self.miles
+
+    def previous_reading(self) -> Optional[int]:
+        """Return the previous valid odometer reading."""
+        first_run = True
+        if self.miles == self.get_minimum():
+            return None
+        while not self.verify_miles() or first_run:
+            first_run = False
+            self.miles -= 1
+        return self.miles
+
+    def nth_reading_after(self, n: int) -> Optional[int]:
+        """Return the nth valid odometer reading."""
+        first_run = True
+        i = 0
+        while not self.verify_miles() or first_run or i < n:
+            if self.miles == self.get_maximum():
+                return None
+            first_run = False
+            self.miles += 1
+            if self.verify_miles():
+                i += 1
+        return self.miles
+
+    def nth_reading_before(self, n: int) -> Optional[int]:
+        """Return the nth valid odometer reading before the current one."""
+        first_run = True
+        i = 0
+        while not self.verify_miles() or first_run or i < n:
+            if self.miles == self.get_minimum():
+                return None
+            first_run = False
+            self.miles -= 1
+            if self.verify_miles():
+                i += 1
+        return self.miles
+
+    @staticmethod
+    def print(start: Optional[int], end) -> None:
+        """Print the start of the odometer with some other value."""
+        print(f"{start} -> {end}")
+
+    @staticmethod
+    def _distance(start: int, end: int) -> int:
+        """Calculate the distance between two odometer readings."""
+        odo_len = len(Odometer._get_digits(start))
+        if odo_len != len(Odometer._get_digits(end)):
+            raise ValueError("Odometer readings must have the same number of digits")
+        n = 0
+        while start != end:
+            try:
+                Odometer._verify_miles(start)
+                n += 1
+                if start == Odometer._get_maximum(odo_len):
+                    start = Odometer._get_minimum(odo_len)
+                else:
+                    start += 1
+            except:
+                start += 1
+        return n
+
+    def distance(self, end: int) -> Optional[int]:
+        """Calculate the distance between the current odometer reading and another."""
+        try:
+            return Odometer._distance(self.miles, end)
+        except:
+            return None
+
+odometer = Odometer(2467)
+Odometer.print(odometer.miles, odometer.get_minimum())
+Odometer.print(odometer.miles, odometer.get_maximum())
+Odometer.print(odometer.miles, odometer.nth_reading_after(6))
+Odometer.print(odometer.miles, odometer.nth_reading_before(6))
+Odometer.print(odometer.miles, odometer.next_reading())
+Odometer.print(odometer.miles, odometer.previous_reading())
+Odometer.print(odometer.miles, f"1234: {odometer.distance(1234)}")
+
+odo2 = Odometer(123)
+Odometer.print(odo2.miles, odo2.get_minimum())
+Odometer.print(odo2.miles, odo2.get_maximum())
+Odometer.print(odo2.miles, odo2.nth_reading_after(83))
+Odometer.print(odo2.miles, f"123: {odo2.distance(123)}")
+
+print(Odometer.possible_values(8))