add movie parsing oop

dsa/d3/exercise_4.py

@@ -0,0 +1,24 @@
+def main():
+    s = "race a car"
+    print(palindrome(s))
+
+def palindrome(s):
+    clean_s = ""
+
+    for x in s:
+        if x.isalpha() or x.isdigit():
+            clean_s+=x.lower()
+    if not clean_s:
+        return False
+
+    left = 0
+    right = len(clean_s)-1
+
+    while left<right:
+        if clean_s[left] != clean_s[right]:
+            return False
+        left+=1
+        right-=1
+    return True
+
+if __name__ == "__main__": main()

dsa/d3/exercise_5.py

@@ -0,0 +1,17 @@
+def main():
+    s = "race e car"
+    print(palindrome(s))
+
+def palindrome(s):
+    cleaned = "".join(ch.lower() for ch in s if ch.isdigit() or ch.isalpha())
+    left = 0
+    right=len(cleaned)-1
+
+    while left<right:
+        if cleaned[left]!=cleaned[right]:
+            return False
+        left+=1
+        right-=1
+    return True
+
+if __name__ == "__main__": main()

dsa/d4/exercise_7.py

@@ -0,0 +1,27 @@
+def main():
+    nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]  # → [4, -1, 2, 1]
+    print(kadane_algorithm(nums))
+
+def kadane_algorithm(nums):
+    current_sum = nums[0]
+    max_sum=nums[0]
+    temp_start=0
+    best_start=0
+    best_end=0
+
+    for i in range(1, len(nums)):
+
+        if current_sum + nums[i]>nums[i]:
+            current_sum=current_sum+nums[i]
+        else:
+            current_sum=nums[i]
+            temp_start=i
+
+        if current_sum>max_sum:
+            max_sum=current_sum
+            best_start=temp_start
+            best_end=i
+
+    return nums[best_start:best_end+1]
+
+if __name__ == "__main__": main()

dsa/d5/exercise_6.py

@@ -0,0 +1,18 @@
+from collections import defaultdict
+
+
+def main():
+    words = ["eat", "tea", "tan", "ate", "nat", "bat"]
+    print(group_anagram(words))
+
+def group_anagram(words):
+
+    result = defaultdict(list)
+
+    for word in words:
+        key="".join(sorted(word))
+        result[key].append(word)
+    return dict(result)
+
+if __name__ == "__main__":
+    main()

dsa/e1/exercise_5.py

@@ -0,0 +1,14 @@
+def main():
+    string = 'eceba'
+    k = 2
+    print(longest_k_distinct(string,k))
+
+def longest_k_distinct(string, k):
+
+    left=0
+    right=0
+    count ={}
+    for right in range(len(string)):
+        count[string[right]] = count.get(string[right], 0) + 1
+        while len(count) > k:
+            count[right]-=1

dsa/e1/exercise_6.py

@@ -0,0 +1,27 @@
+def main():
+    string = 'eceba'
+    k = 2
+    print(longest_k_distinct(string,k))
+
+def longest_k_distinct(s, k):
+    left=0
+    seen={}
+    max_length=0
+    best_start=0
+    for right in range(len(s)):
+        seen[s[right]] = seen.get(s[right],0)+1
+
+        while len(seen) > k:
+            seen[s[left]]-=1
+
+            if seen[s[left]]==0:
+                del seen[s[left]]
+            left+=1
+
+        if right - left + 1 > max_length:
+            max_length = right - left + 1
+            best_start = left
+
+    return s[best_start:best_start+max_length]
+
+if __name__ == "__main__": main()

dsa/e2/exercise_4.py

@@ -0,0 +1,17 @@
+def main():
+    a = [3,1,4,1,5]
+    b = [1,5,9,1]
+    print(ordered_intersection(a,b))
+
+def ordered_intersection(a,b):
+    in_b = set(b)
+    added=set()
+    result=[]
+
+    for x in a:
+        if x not in added and x in in_b:
+            added.add(x)
+            result.append(x)
+    return result
+
+if __name__ == "__main__": main()

dsa/e3/exercise_6.py

@@ -0,0 +1,28 @@
+from collections import defaultdict
+
+
+def main():
+    logs = [
+        "ivan,login,09:00", "ivan,upload,09:05", "ivan,login,09:10",
+        "maria,login,09:02", "maria,delete,09:06", "maria,upload,09:07",
+        "BAD",
+        "georgi,login,09:20",
+    ]
+    print(most_versatile_user(logs))
+
+def most_versatile_user(logs):
+    versatile_users = defaultdict(set)
+    for log in logs:
+        try:
+            user, action, date = log.split(",")
+        except (AttributeError, ValueError):
+            continue
+        else:
+            versatile_users[user].add(action)
+    if not versatile_users:
+        return None
+    user = min(versatile_users, key=lambda u:(-len(versatile_users[u]), u))
+    return user, len(versatile_users[user])
+
+if __name__ == "__main__":
+    main()

dsa/e3/exercise_7.py

@@ -0,0 +1,30 @@
+from collections import defaultdict
+
+
+def main():
+    logs = [
+        "ivan,login,09:00", "ivan,upload,09:05", "ivan,login,09:10",
+        "maria,login,09:02", "maria,delete,09:06", "maria,upload,09:07",
+        "BAD",
+        "georgi,login,09:20",
+    ]
+    print(most_versatile_user(logs))
+
+def most_versatile_user(logs):
+
+    versatile_users=defaultdict(set)
+    for log in logs:
+        try:
+            user,action,time=log.split(",")
+        except (AttributeError, ValueError):
+            continue
+        else:
+            versatile_users[user].add(action)
+
+    if not versatile_users:
+        return None
+
+    user = max(versatile_users, key=lambda u:len(versatile_users[u]))
+    return user, len(versatile_users[user])
+
+if __name__ == "__main__": main()

dsa/e4/exercise_5.py

@@ -0,0 +1,31 @@
+def main():
+    a = [1,3,5]
+    b = [2,4,6]
+    print(merge_sorted(a,b))
+
+def merge_sorted(a,b):
+
+    result =[]
+    left=0
+    right=0
+
+    while left<len(a) and right<len(b):
+        if a[left] < b[right]:
+            result.append(a[left])
+            left+=1
+        else:
+            result.append(b[right])
+            right+=1
+
+    while left<len(a):
+        result.append(a[left])
+        left+=1
+
+    while right<len(b):
+        result.append(b[right])
+        right+=1
+
+    return result
+
+if __name__ == "__main__":
+    main()

exercise/decorator/exercise_1.py

@@ -51,5 +51,20 @@ def wrapper(*args, **kwargs):
 def get_ice_cream(flavor):
     print(f"Here is your {flavor} ice cream 🍨")
 
-get_ice_cream("chocolate")
+#get_ice_cream("chocolate")
+
+def timer(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        start = time.perf_counter()
+        result = func(*args, **kwargs)
+        print(f"{func.__name__} took {time.perf_counter() - start:.4f}s")
+        return result
+    return wrapper
+
+@timer
+def slow_sum(n):
+    return sum(range(n))
+
+print(slow_sum(5))
 

hashing/task1/exercise_1.py

@@ -4,7 +4,6 @@ def main():
     output = first_none_repeating(user_input)
     print(output)
 
-
 def first_none_repeating(s: str):
     if s is None or s == "":
         return '_'

movie_catalog_parser/exercise_1.py

@@ -0,0 +1,98 @@
+from collections import defaultdict
+
+class InvalidMovieError(Exception): pass
+
+class Movie:
+
+    def __init__(self,title, genre, rating, votes):
+        self.title =title
+        self.genre=genre
+        self.rating=rating
+        self.votes=votes
+
+    def __repr__(self):
+        return f"{self.title} ({self.rating})"
+
+
+    @classmethod
+    def from_line(cls, line):
+        try:
+            title, genre, rating, votes=line.split(",")
+            rating = float(rating)
+            votes=int(votes)
+        except ValueError:
+            raise InvalidMovieError("Invalid movie")
+
+        if not 0<=rating<=10:
+            raise InvalidMovieError("Invalid rating")
+
+        return cls(title.strip(), genre.strip(), rating, votes)
+
+
+
+class Catalog:
+    def __init__(self):
+        self.movies=[]
+
+    def add_movie(self, movie):
+        self.movies.append(movie)
+
+    def average_rating_by_genre(self):
+        genre_ratings=defaultdict(list)
+        for movie in self.movies:
+            genre_ratings[movie.genre].append(movie.rating)
+        result = {}
+        for genre, rating in genre_ratings.items():
+            result[genre] = round(sum(rating)/len(rating), 2)
+        return result
+
+    def top_rated(self, n):
+        return sorted(
+            self.movies,
+            key=lambda movie: (-movie.rating, movie.title)
+        )[:n]
+
+    def most_voted(self):
+        return max(self.movies, key=lambda m:m.votes)
+
+    def genres(self):
+        genres=[]
+        added=[]
+        for m in self.movies:
+            if m.genre not in added:
+                added.append(m.genre)
+                genres.append(m.genre)
+        return sorted(genres)
+        #return sorted(set(m.genre for m in self.movies))
+
+def read_from_file(file_name):
+    lines=[]
+    try:
+        with open(file_name, "r") as f:
+            lines = f.readlines()
+    except FileNotFoundError:
+        print("File not found")
+        return []
+    else:
+        return lines
+
+def main():
+    catalog = Catalog()
+    lines = read_from_file("sample.txt")
+    skipped=0
+
+    for line in lines:
+        if not line.strip():
+            continue
+        try:
+            catalog.add_movie(Movie.from_line(line.strip()))
+        except InvalidMovieError:
+            skipped+=1
+    print(f"Skipped {skipped} malformed lines")
+    print(f"Average rating by genre: {catalog.average_rating_by_genre()}")
+    print(f"Top rated: {catalog.top_rated(3)}")
+    print(f"Most voted: {catalog.most_voted()}")
+    print(f"Genres: {catalog.genres()}")
+
+if __name__ == "__main__":
+    main()

movie_catalog_parser/sample.txt

@@ -0,0 +1,9 @@
+Inception,SciFi,8.8,2000000
+The Room,Drama,3.7,150000
+Interstellar,SciFi,8.6,1500000
+Parasite,Thriller,8.5,800000
+BadRating,Drama,12.5,1000
+Cats,Musical,2.8,50000
+Whiplash,Drama,8.5,700000
+Broken,SciFi,notanumber,500
+Tenet,SciFi,7.4