Completed 31 Bawadharani Sree

December 01/python3_BawadharaniSree_The_Vanishing_Number.py

@@ -0,0 +1,5 @@
+N=int(input("Enter the Number of participants: "))
+arr=list(map(int,input("Enter bib number with sapce:").split()))
+total_sum=(N*(N+1))//2
+missing_bib=total_sum-sum(arr)
+print("The missing BIB: ",missing_bib)

December 02/python3_BawadharaniSree_The_Wave_Sort_Challenge.py

@@ -0,0 +1,8 @@
+arr=list(map(int,input().split()))
+for i in range(len(arr)-1):
+   if(i%2==0):
+      if (arr[i]<arr[i+1]):
+         arr[i],arr[i+1]=arr[i+1],arr[i]
+   elif (arr[i]>arr[i+1]):
+      arr[i],arr[i+1]=arr[i+1],arr[i]
+print(arr) 

December 03/python3_BawadharaniSree_Alternating_Square_Arrangement.py

@@ -0,0 +1,15 @@
+R=int(input("Enter the number if Red squares: "))
+B=int(input("Enter the number if Blue squares: "))
+if(abs(R-B)!=1):
+   print("Not Possible")
+else:
+   if(R>B):
+      for i in range(min(R,B)):
+         if(R>B):
+            print("RB",end="")
+         else:
+            print("BR",end="")
+      if(R>B):
+         print("R")
+      else:
+         print("B")

December 04/python3_BawadharaniSree_Plant_Growth_Tracker.py

@@ -0,0 +1,12 @@
+def plant_growth_tracker(n):
+    if n == 1 or n == 2:
+        return 1
+    prev1, prev2 = 1, 1
+    for _ in range(3, n + 1):
+        current = prev1 + prev2
+        prev1, prev2 = prev2, current
+    return current
+if __name__ == '__main__':
+   n = int(input("Enter the number of months: "))
+   result = plant_growth_tracker(n)
+   print("Number of plants after", n, "months:", result)

December 05/python3_BawadharaniSree_Josephus_Problem.py

@@ -0,0 +1,9 @@
+def josephus(n, k):
+    if n == 1:
+        return 1
+    else:
+        return (josephus(n - 1, k) + k - 1) % n + 1
+n = int(input("Enter the number of people (n): "))
+k = int(input("Enter the step size (k): "))
+safe_position = josephus(n, k)
+print(f"The safe position for n = {n} and k = {k} is: {safe_position}")

December 06/python3_BawadharaniSree_Target_Pair_Finder.py

@@ -0,0 +1,17 @@
+def find_target_pairs(numbers, target):
+    unique_pairs = []
+    visited = set()
+    for i in range(len(numbers)):
+        for j in range(i + 1, len(numbers)):
+            if numbers[i] + numbers[j] == target:
+                pair = tuple(sorted((numbers[i], numbers[j])))
+                if pair not in visited:
+                    unique_pairs.append(pair)
+                    visited.add(pair)
+    return unique_pairs
+
+numbers_input = input("Enter a list of integers (comma-separated): ")
+numbers = list(map(int, numbers_input.split(',')))
+target = int(input("Enter the target sum: "))
+result = find_target_pairs(numbers, target)
+print("Unique pairs are:", result)

December 07/python3_BawadharaniSree_The_Magical_Tower.py

@@ -0,0 +1,14 @@
+def generate_magical_tower(numRows):
+    tower = []
+    for i in range(numRows):
+        floor = [1]
+        for j in range(1, i):
+            floor.append(tower[i-1][j-1] + tower[i-1][j])
+        if i > 0:
+            floor.append(1)
+        tower.append(floor)
+    return tower
+
+numRows = int(input("Enter the number of floors (numRows): "))
+tower = generate_magical_tower(numRows)
+print("The Magical Tower:", tower)

December 08/python3_BawadharaniSree_Digit_Manipulation.py

@@ -0,0 +1,10 @@
+def digit_square_sum(n):
+    total_sum = 0
+    for i in range(1, n + 1):
+        digit_sum = sum(int(digit) ** 2 for digit in str(i))
+        total_sum += digit_sum
+    return total_sum
+
+N = int(input("Enter a positive integer N: "))
+result = digit_square_sum(N)
+print("The total Digit Square Sum is:", result)

December 09/python3_BawadharaniSree_Customer_Return_Frequency.py

@@ -0,0 +1,6 @@
+def count_customers(returns):
+    return returns.count(1)
+
+returns = list(map(int, input("Enter the return frequencies separated by spaces: ").split()))
+result = count_customers(returns)
+print(result)

December 10/python3_BawadharaniSree_Concurrent_Task_Execution.py

@@ -0,0 +1,35 @@
+from collections import defaultdict, deque
+
+def find_task_order(tasks):
+    graph = defaultdict(list)
+    in_degree = defaultdict(int)
+    for task, dependencies in tasks:
+        for dep in dependencies:
+            graph[dep].append(task)
+            in_degree[task] += 1
+        in_degree.setdefault(task, 0)
+    queue = deque([task for task in in_degree if in_degree[task] == 0])
+    result = []
+    while queue:
+        current_level = []
+        for _ in range(len(queue)):
+            task = queue.popleft()
+            current_level.append(task)
+            for neighbor in graph[task]:
+                in_degree[neighbor] -= 1
+                if in_degree[neighbor] == 0:
+                    queue.append(neighbor)
+        result.append(current_level)
+    return result if sum(in_degree.values()) == 0 else "Error: Cyclic dependency detected"
+
+def get_tasks_from_user():
+    n = int(input("Enter the number of tasks: "))
+    tasks = [
+        (input("Task ID: "), input("Dependencies (comma-separated, leave blank if none): ").split(",") if input("Dependencies (comma-separated, leave blank if none): ").strip() else [])
+        for _ in range(n)
+    ]
+    return tasks
+
+if __name__ == "__main__":
+    user_tasks = get_tasks_from_user()
+    print("Output:", find_task_order(user_tasks))

December 11/python3_BawadharaniSree_The_Robot_Returns.py

@@ -0,0 +1,16 @@
+def robot_returns_to_origin(moves):
+    x, y = 0, 0
+    for move in moves:
+        if move == 'U':
+            y += 1
+        elif move == 'D':
+            y -= 1
+        elif move == 'R':
+            x += 1
+        elif move == 'L':
+            x -= 1
+    return x == 0 and y == 0
+
+if __name__ == "__main__":
+    moves = input("Enter the robot's moves: ")
+    print("Output:", robot_returns_to_origin(moves))

December 12/python3_BawadharaniSree_Smart_Ticketing_System.py

@@ -0,0 +1,60 @@
+from collections import deque
+
+def process_ticket_requests(N, requests):
+    queue = deque()
+    for request in requests:
+        parts = request.split()
+        name = parts[0]
+        tickets = int(parts[1])
+        is_vip = len(parts) == 3 and parts[2] == "VIP"
+        queue.append((name, tickets, is_vip))
+
+    result = []
+    vip_queue = deque()
+    regular_queue = deque()
+
+    while queue:
+        name, tickets, is_vip = queue.popleft()
+        if is_vip:
+            vip_queue.append((name, tickets))
+        else:
+            regular_queue.append((name, tickets))
+
+    while N > 0 and (vip_queue or regular_queue):
+        if vip_queue:
+            name, tickets = vip_queue.popleft()
+        else:
+            name, tickets = regular_queue.popleft()
+
+        if tickets <= N:
+            N -= tickets
+            result.append(f"{name} purchased {tickets} tickets")
+        else:
+            result.append(f"{name} purchased {N} tickets")
+            N = 0
+
+    while vip_queue or regular_queue:
+        if vip_queue:
+            name, _ = vip_queue.popleft()
+        else:
+            name, _ = regular_queue.popleft()
+        result.append(f"{name} was not served")
+
+    return result
+
+
+N = int(input("Enter the number of tickets available: "))
+requests = []
+print("Enter ticket requests (format: 'CustomerName NumberOfTickets [VIP]'):")
+print("Type 'done' when finished.")
+
+while True:
+    request = input()
+    if request.lower() == "done":
+        break
+    requests.append(request)
+
+
+results = process_ticket_requests(N, requests)
+for res in results:
+    print(res)

December 13/python3_BawadharaniSree_Minimum_Swap_Sorting_Problem.py

@@ -0,0 +1,30 @@
+def minimum_swaps_to_sort(arr):
+    n = len(arr)
+    visited = [False] * n
+    arr_with_indices = list(enumerate(arr))
+    arr_with_indices.sort(key=lambda x: x[1])
+    swaps = 0
+
+    for i in range(n):
+        if visited[i] or arr_with_indices[i][0] == i:
+            continue
+
+        cycle_size = 0
+        j = i
+        while not visited[j]:
+            visited[j] = True
+            j = arr_with_indices[j][0]
+            cycle_size += 1
+
+        if cycle_size > 1:
+            swaps += cycle_size - 1
+
+    return swaps
+
+
+N = int(input("Enter the number of integers: "))
+arr = list(map(int, input("Enter the integers separated by spaces: ").split()))
+
+
+result = minimum_swaps_to_sort(arr)
+print(result)

December 14/python3_BawadharaniSree_Split_the_Squad.py

@@ -0,0 +1,38 @@
+def can_divide_students(t, test_cases):
+    results = []
+    for case in test_cases:
+        n, k, d, subjects = case
+        unique_subjects = len(set(subjects))
+        if k > unique_subjects or unique_subjects > 2 * k or n < 2:
+            results.append("NO")
+            continue
+
+        min_team_size = max(1, n // 2 - d // 2)
+        max_team_size = min(n // 2 + d // 2, n - min_team_size)
+
+        team1 = set()
+        team2 = set()
+
+        for subject in subjects:
+            if len(team1) < max_team_size and (len(team1) < k or subject in team1):
+                team1.add(subject)
+            elif len(team2) < max_team_size and (len(team2) < k or subject in team2):
+                team2.add(subject)
+
+        if len(team1) >= min_team_size and len(team2) >= min_team_size and len(team1) <= max_team_size and len(team2) <= max_team_size:
+            results.append("YES")
+        else:
+            results.append("NO")
+
+    return results
+
+t = int(input())
+test_cases = []
+for _ in range(t):
+    n, k, d = map(int, input().split())
+    subjects = list(map(int, input().split()))
+    test_cases.append((n, k, d, subjects))
+
+results = can_divide_students(t, test_cases)
+for result in results:
+    print(result)

December 15/python3_BawadharaniSree_Holiday_Gift_Arrangement.py

@@ -0,0 +1,19 @@
+def minTrips(houses, W):
+    trip_count = 0
+    current_sum = 0
+
+    for gifts in houses:
+        if current_sum + gifts > W:
+            trip_count += 1
+            current_sum = gifts
+        else:
+            current_sum += gifts
+
+    if current_sum > 0:
+        trip_count += 1
+
+    return trip_count
+
+houses = list(map(int, input("Houses= ").split()))
+W = int(input("W="))
+print(minTrips(houses, W))

December 16/python3_BawadharaniSree_Train_Platform_Calculation.py

@@ -0,0 +1,23 @@
+def minPlatforms(arrivals, departures):
+    arrivals.sort()
+    departures.sort()
+
+    platforms_needed = 0
+    max_platforms = 0
+    i, j = 0, 0
+
+    while i < len(arrivals) and j < len(departures):
+        if arrivals[i] <= departures[j]:
+            platforms_needed += 1
+            i += 1
+        else:
+            platforms_needed -= 1
+            j += 1
+
+        max_platforms = max(max_platforms, platforms_needed)
+
+    return max_platforms
+
+arrivals = list(map(int, input("arrivals= ").split()))
+departures = list(map(int, input("depatures= ").split()))
+print(f"Minimum platforms required: {minPlatforms(arrivals, departures)}")

December 17/python3_BawadharaniSree_Cybersecurity_Alert_Management.py

@@ -0,0 +1,50 @@
+from datetime import datetime
+import json
+class AlertManager:
+    def __init__(self):
+        self.alerts = {}
+
+    def parse_time(self, time_str):
+        return datetime.strptime(time_str, "%H:%M:%S")
+
+    def process_alert(self, alert):
+        alert_id = alert["id"]
+        timestamp = self.parse_time(alert["timestamp"])
+        threat_level = alert["threat_level"]
+
+        current_time = timestamp
+        for key in list(self.alerts.keys()):
+            if (current_time - self.alerts[key]["timestamp"]).total_seconds() > 300:
+                del self.alerts[key]
+
+        if alert_id in self.alerts:
+            existing_alert = self.alerts[alert_id]
+            if (timestamp - existing_alert["timestamp"]).total_seconds() <= 30:
+                if threat_level > existing_alert["threat_level"]:
+                    self.alerts[alert_id]["timestamp"] = timestamp
+                    self.alerts[alert_id]["threat_level"] = threat_level
+                return
+
+        self.alerts[alert_id] = {
+            "timestamp": timestamp,
+            "threat_level": threat_level
+        }
+
+    def get_stored_alerts(self):
+        return [
+            {
+                "id": alert_id,
+                "timestamp": alert["timestamp"].strftime("%H:%M:%S"),
+                "threat_level": alert["threat_level"]
+            }
+            for alert_id, alert in self.alerts.items()
+        ]
+
+alerts = json.loads(input())
+
+manager1 = AlertManager()
+for alert in alerts:
+    manager1.process_alert(alert)
+
+print("Stored alerts:")
+print(manager1.get_stored_alerts())