fix merge conflicts

Author: adde9708

find_repeated_dna_sequences.py

@@ -1,11 +1,10 @@
 from time import perf_counter_ns
 
 
-def add_hash(ans, hash_set, hash_val, repeated_sequence):
-    if hash_val in hash_set and repeated_sequence not in ans:
-        ans.add(repeated_sequence)
-    else:
-        hash_set.add(hash_val)
+def create_hash(s, nucleotide_mapping, hash_val):
+    for i in range(10):
+        hash_val = (hash_val * 4) + nucleotide_mapping[s[i]]
+    return {hash_val}
 
 
 def build_hash(s, nucleotide_mapping, start_index):
@@ -17,23 +16,31 @@ def build_hash(s, nucleotide_mapping, start_index):
 
 def loop_through_hash_set(s, ans, lst_len, nucleotide_mapping, hash_set):
     for i in range(1, lst_len - 9):
-        repeated_sequence = s[i : i + 10]
-        hash_val = build_hash(s, nucleotide_mapping, i - 1)
-        add_hash(ans, hash_set, hash_val, repeated_sequence)
+        hash_val = (
+            (hash_val - nucleotide_mapping[s[i - 1]] * base) * 4
+        ) + nucleotide_mapping[s[i + 9]]
+
+        if hash_val in hash_set:
+            repeated_sequence = s[i : i + 10]
+            ans.add(repeated_sequence)
+        else:
+            hash_set.add(hash_val)
 
 
 def find_repeated_dna_sequences(s):
     ans = set()
     lst_len = len(s)
-
     if lst_len < 10:
-        return list(ans)
+        return []
 
-    nucleotide_mapping = {"A": 1, "C": 2, "G": 3, "T": 4}
+    nucleotide_mapping = {"A": 0, "C": 1, "G": 2, "T": 3}
+    hash_val = 0
 
-    hash_val = build_hash(s, nucleotide_mapping, 0)
-    hash_set = {hash_val}
-    loop_through_hash_set(s, ans, lst_len, nucleotide_mapping, hash_set)
+    # Initial hash computation for first 10 characters
+    hash_set = create_hash(s, nucleotide_mapping, hash_val)
+
+    # Compute rolling hash for the rest of the string
+    compute_rolling_hash(s, lst_len, nucleotide_mapping, hash_set, ans)
 
     return list(ans)
 
@@ -43,11 +50,11 @@ def main():
     s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
     print("Benchmarking find_repeated_dna_sequences...")
     start_time = perf_counter_ns()
+
     for _ in range(1000):
         ans = find_repeated_dna_sequences(s)
         print(ans)
 
-    print()
     end_time = perf_counter_ns()
     total_time = end_time - start_time
     print("Total time taken for 1000 iterations:", total_time, "nanoseconds")

help_queue.py

@@ -1,34 +1,26 @@
 import threading
 from typing import Optional
+from dataclasses import dataclass, field
 
 
+@dataclass
 class Node:
-    def __init__(self, value: int) -> None:
-        self._padding: bytes = b"\x00" * (64 - (8 + 8))
-        self.value: int = value
-        self.next: Optional[Node] = None
-        self.mutex: threading.Lock = threading.Lock()
+    value: int
+    next: Optional["Node"] = None
+    mutex: threading.Lock = field(default_factory=threading.Lock, init=False)
+    _padding: bytes = field(default=b"\x00" * (64 - (8 + 8)), init=False)
 
 
+@dataclass
 class Queue:
-    def __init__(self) -> None:
-        dummy_value: int = 0
-        self.dummy_node: Node = Node(dummy_value)
-        self.head: Node = self.dummy_node
-        self.tail: Node = self.dummy_node
-        self.mutex: threading.Lock = threading.Lock()
+    dummy_node: Node = field(default_factory=lambda: Node(0), init=False)
+    head: Node = field(init=False)
+    tail: Node = field(init=False)
+    mutex: threading.Lock = field(default_factory=threading.Lock, init=False)
 
-
-def try_remove_front(queue: Queue, front: int) -> bool:
-    with queue.mutex:
-        head: Node = queue.head
-        if head.next is not None:
-            with head.mutex:
-                next_node: Node = head.next
-                if next_node.value == front:
-                    head.next = next_node.next
-                    return True
-    return False
+    def __post_init__(self):
+        self.head = self.dummy_node
+        self.tail = self.dummy_node
 
 
 def help_finish_enq(queue: Queue) -> None:
@@ -47,6 +39,18 @@ def enqueue(queue: Queue, value: int) -> None:
         help_finish_enq(queue)
 
 
+def try_remove_front(queue: Queue, front: int) -> bool:
+    with queue.mutex:
+        head: Node = queue.head
+        if head.next is not None:
+            with head.mutex:
+                next_node: Node = head.next
+                if next_node.value == front:
+                    head.next = next_node.next
+                    return True
+    return False
+
+
 def main() -> None:
     q: Queue = Queue()
     front_value: int = 10

pong.py

@@ -0,0 +1,122 @@
+import pygame
+import sys
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Settings:
+    # Constants
+    WIDTH, HEIGHT = 640, 480
+    WHITE = (255, 255, 255)
+    BLACK = (0, 0, 0)
+    PADDLE_WIDTH, PADDLE_HEIGHT = 10, 100
+    BALL_SIZE = 15
+    PADDLE_SPEED = 10
+
+
+# Initialize Pygame
+def init_pygame():
+    pygame.init()
+
+
+def setup_display():
+    # Set up the display
+    screen = pygame.display.set_mode((Settings.WIDTH, Settings.HEIGHT))
+    pygame.display.set_caption("Pong Game")
+    return screen
+
+
+# Create initial ball and players positions
+def create_ball_and_players():
+    left_paddle = pygame.Rect(
+        30,
+        (Settings.HEIGHT - Settings.PADDLE_HEIGHT) // 2,
+        Settings.PADDLE_WIDTH,
+        Settings.PADDLE_HEIGHT,
+    )
+    right_paddle = pygame.Rect(
+        Settings.WIDTH - 40,
+        (Settings.HEIGHT - Settings.PADDLE_HEIGHT) // 2,
+        Settings.PADDLE_WIDTH,
+        Settings.PADDLE_HEIGHT,
+    )
+    ball = pygame.Rect(
+        Settings.WIDTH // 2,
+        Settings.HEIGHT // 2,
+        Settings.BALL_SIZE,
+        Settings.BALL_SIZE,
+    )
+
+    return left_paddle, right_paddle, ball
+
+
+def get_keys():
+    return pygame.key.get_pressed()
+
+
+# Function to handle player movement
+def player_movement(left_paddle, right_paddle):
+
+    keys = get_keys()
+
+    if keys[pygame.K_w] and left_paddle.top > 0:
+        left_paddle.y -= Settings.PADDLE_SPEED
+
+    elif keys[pygame.K_s] and left_paddle.bottom < Settings.HEIGHT:
+        left_paddle.y += Settings.PADDLE_SPEED
+
+    if keys[pygame.K_UP] and right_paddle.top > 0:
+        right_paddle.y -= Settings.PADDLE_SPEED
+
+    elif keys[pygame.K_DOWN] and right_paddle.bottom < Settings.HEIGHT:
+        right_paddle.y += Settings.PADDLE_SPEED
+
+
+def set_ball_speed():
+    ball_speed_x, ball_speed_y = 10, 10
+    return ball_speed_x, ball_speed_y
+
+
+# Function to draw objects on screen
+def draw_screen(left_paddle, right_paddle, ball, screen):
+    screen.fill(Settings.BLACK)
+    pygame.draw.rect(screen, Settings.WHITE, left_paddle)
+    pygame.draw.rect(screen, Settings.WHITE, right_paddle)
+    pygame.draw.ellipse(screen, Settings.WHITE, ball)
+    pygame.display.flip()
+    pygame.time.delay(16)
+
+
+# Main game loop
+def main():
+    init_pygame()
+    screen = setup_display()
+
+    left_paddle, right_paddle, ball = create_ball_and_players()
+    ball_speed_x, ball_speed_y = set_ball_speed()  # Initial ball speeds
+    while True:
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                pygame.quit()
+                sys.exit()
+        player_movement(left_paddle, right_paddle)
+
+        ball.x += ball_speed_x
+        ball.y += ball_speed_y
+
+        if ball.top <= 0 or ball.bottom >= Settings.HEIGHT:
+            ball_speed_y = -ball_speed_y
+
+        if ball.colliderect(left_paddle) or ball.colliderect(right_paddle):
+            ball_speed_x = -ball_speed_x
+
+        if ball.left <= 0 or ball.right >= Settings.WIDTH:
+            ball_speed_x = -ball_speed_x
+            ball.x = Settings.WIDTH // 2
+            ball.y = Settings.HEIGHT // 2
+
+        draw_screen(left_paddle, right_paddle, ball, screen)
+
+
+if __name__ == "__main__":
+    main()