Add files via upload

answers/CircuitQueue.py

@@ -0,0 +1,45 @@
+class CircularQueue:
+    def __init__(self, max_size):
+        self.max_size = max_size
+        self.queue = [None] * max_size
+        self.front = 0
+        self.rear = 0
+        self.count = 0
+
+    def enqueue(self, item):
+        if self.count == self.max_size:
+            print("Queue is full")
+            return
+        self.queue[self.rear] = item
+        self.rear = (self.rear + 1) % self.max_size
+        self.count += 1
+
+    def dequeue(self):
+        if self.count == 0:
+            print("Queue is empty")
+            return None
+        item = self.queue[self.front]
+        self.front = (self.front + 1) % self.max_size
+        self.count -= 1
+        return item
+
+    def is_empty(self):
+        return self.count == 0
+
+    def size(self):
+        return self.count
+
+# Example usage:
+cq = CircularQueue(5)
+print("Is empty?", cq.is_empty())  # Is empty? True
+cq.enqueue(1)
+cq.enqueue(2)
+cq.enqueue(3)
+print("Size:", cq.size())  # Size: 3
+print("Dequeue:", cq.dequeue())  # Dequeue: 1
+print("Size:", cq.size())  # Size: 2
+cq.enqueue(4)
+cq.enqueue(5)
+cq.enqueue(6)  # Queue is full
+print("Is empty?", cq.is_empty())  # Is empty? False
+print("Size:", cq.size())  # Size: 5

answers/PriorityQueue.py

@@ -0,0 +1,34 @@
+class PriorityQueue:
+    def __init__(self):
+        self.queue = []
+
+    def enqueue(self, item, priority):
+        self.queue.append((item, priority))
+        self.queue.sort(key=lambda x: x[1])
+
+    def dequeue(self):
+
+        if self.is_empty():
+            raise IndexError("Dequeue from empty priority queue")
+        return self.queue.pop(0)[0]
+
+    def is_empty(self):
+        return len(self.queue) == 0
+
+    def size(self):
+        return len(self.queue)
+
+
+# Example usage:
+pq = PriorityQueue()
+print("Is the priority queue empty?", pq.is_empty())  # Output: True
+
+pq.enqueue('task1', 3)
+pq.enqueue('task2', 1)
+pq.enqueue('task3', 2)
+
+print("Priority queue size:", pq.size())  # Output: 3
+print("Is the priority queue empty?", pq.is_empty())  # Output: False
+
+print("Dequeued item:", pq.dequeue())  # Output: 'task2' (highest priority)
+print("Priority queue size after dequeue:", pq.size())  # Output: 2

answers/Queue.py

@@ -0,0 +1,34 @@
+class Queue:
+    def __init__(self):
+        self.items = []
+
+    def enqueue(self, item):
+        self.items.append(item)
+
+    def dequeue(self):
+
+        if self.is_empty():
+            raise IndexError("Dequeue from empty queue")
+        return self.items.pop(0)
+
+    def is_empty(self):
+        return len(self.items) == 0
+
+    def size(self):
+        return len(self.items)
+
+
+# Example usage:
+q = Queue()
+print("Is the queue empty?", q.is_empty())  # Output: True
+
+q.enqueue('a')
+q.enqueue('b')
+q.enqueue('c')
+
+
+print("Queue size:", q.size())  # Output: 3
+print("Is the queue empty?", q.is_empty())  # Output: False
+
+print("Dequeued item:", q.dequeue())  # Output: 'a'
+print("Queue size after dequeue:", q.size())  # Output: 2

answers/Task1.py

@@ -0,0 +1,62 @@
+from collections import deque
+
+class Queue:
+    def __init__(self):
+        self.queue = deque()
+
+    def enqueue(self, item):
+        self.queue.append(item)
+
+    def dequeue(self):
+        if self.is_empty():
+            print("Queue is empty")
+            return None
+        return self.queue.popleft()
+
+    def is_empty(self):
+        return len(self.queue) == 0
+
+    def size(self):
+        return len(self.queue)
+
+def is_valid_move(maze, visited, row, col):
+    return (0 <= row < len(maze)) and (0 <= col < len(maze[0])) and (maze[row][col] == '0') and (not visited[row][col])
+
+def find_shortest_path(maze, start, end):
+    rows, cols = len(maze), len(maze[0])
+    visited = [[False for _ in range(cols)] for _ in range(rows)]
+    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
+
+    q = Queue()
+    q.enqueue((start, [start]))  # Store the current position and the path taken to reach there
+    visited[start[0]][start[1]] = True
+
+    while not q.is_empty():
+        (current, path) = q.dequeue()
+        if current == end:
+            return path
+
+        for direction in directions:
+            next_row, next_col = current[0] + direction[0], current[1] + direction[1]
+            if is_valid_move(maze, visited, next_row, next_col):
+                visited[next_row][next_col] = True
+                q.enqueue(((next_row, next_col), path + [(next_row, next_col)]))
+
+    return None  # No path found
+
+# Example usage:
+maze = [
+    ['0', '1', '0', '0', '0'],
+    ['0', '1', '0', '1', '0'],
+    ['0', '0', '0', '1', '0'],
+    ['0', '1', '1', '1', '0'],
+    ['0', '0', '0', '0', '0']
+]
+start = (0, 0)
+end = (4, 4)
+
+path = find_shortest_path(maze, start, end)
+if path:
+    print("Shortest path:", path)
+else:
+    print("No path found")

answers/Task2.py

@@ -0,0 +1,39 @@
+class Queue:
+    def __init__(self):
+        self.queue = []
+
+    def enqueue(self, item):
+        self.queue.append(item)
+
+    def dequeue(self):
+        if self.is_empty():
+            print("Queue is empty")
+            return None
+        return self.queue.pop(0)
+
+    def is_empty(self):
+        return len(self.queue) == 0
+
+    def size(self):
+        return len(self.queue)
+
+def josephus(n, k):
+    q = Queue()
+    for i in range(1, n + 1):
+        q.enqueue(i)
+
+    while q.size() > 1:
+        for _ in range(k - 1):
+            q.enqueue(q.dequeue())
+        q.dequeue()  # This is the k-th person to be eliminated
+
+    return q.dequeue()
+
+def main():
+    n = int(input("Enter the number of participants (n): "))
+    k = int(input("Enter the number of participants to skip (k): "))
+    result = josephus(n, k)
+    print(f"The last remaining person is at position: {result}")
+
+if __name__ == "__main__":
+    main()

answers/Task3.py

@@ -0,0 +1,68 @@
+class AsciiPriorityQueue:
+    def __init__(self, string):
+        self.queue = []
+        for char in string:
+            self.enqueue(char)
+
+    def enqueue(self, item):
+        self.queue.append(item)
+        self._heapify_up(len(self.queue) - 1)
+
+    def dequeue(self):
+        if self.is_empty():
+            print("Queue is empty")
+            return None
+        # Swap the first and the last item, remove the last (maximum) item
+        self._swap(0, len(self.queue) - 1)
+        highest = self.queue.pop()
+        self._heapify_down(0)
+        return highest
+
+    def is_empty(self):
+        return len(self.queue) == 0
+
+    def size(self):
+        return len(self.queue)
+
+    def print(self):
+        print(", ".join(self.queue))
+
+    def _heapify_up(self, index):
+        parent_index = (index - 1) // 2
+        if parent_index >= 0 and self.queue[index] > self.queue[parent_index]:
+            self._swap(index, parent_index)
+            self._heapify_up(parent_index)
+
+    def _heapify_down(self, index):
+        largest = index
+        left_child = 2 * index + 1
+        right_child = 2 * index + 2
+
+        if left_child < len(self.queue) and self.queue[left_child] > self.queue[largest]:
+            largest = left_child
+
+        if right_child < len(self.queue) and self.queue[right_child] > self.queue[largest]:
+            largest = right_child
+
+        if largest != index:
+            self._swap(index, largest)
+            self._heapify_down(largest)
+
+    def _swap(self, i, j):
+        self.queue[i], self.queue[j] = self.queue[j], self.queue[i]
+
+def main():
+    string = input("Enter the sequence of characters: ")
+    queue = AsciiPriorityQueue(string)
+
+    print("Initial queue state:")
+    queue.print()
+
+    while not queue.is_empty():
+        removed_item = queue.dequeue()
+        print(f"Dequeued item with highest ASCII value: {removed_item}")
+        print("Current queue state:")
+        queue.print()
+
+if __name__ == "__main__":
+    main()