presudo 1.0.0

package/pods/sudo/backend/restaurant ordering system.txt

@@ -0,0 +1,104 @@
+Design a Python module for managing a restaurant ordering system
+
+from abc import ABC, abstractmethod
+
+# -------------------- Abstraction --------------------
+class MenuItem(ABC):
+   def __init__(self, name, price):
+       self.name = name
+       self.price = price
+   @abstractmethod
+   def get_price(self):
+       pass
+
+# -------------------- Inheritance & Polymorphism --------------------
+class VegItem(MenuItem):
+   def get_price(self):
+       return self.price
+
+class NonVegItem(MenuItem):
+   def get_price(self):
+       return self.price + 20   # extra charge for non-veg
+
+# -------------------- Order Class --------------------
+class Order:
+   def __init__(self):
+       self.items = []
+   def add_item(self, item):
+       self.items.append(item)
+   def remove_item(self, name):
+       for item in self.items:
+           if item.name == name:
+               self.items.remove(item)
+               return True
+       return False
+   def calculate_total(self):
+       total = 0
+       for item in self.items:
+           total += item.get_price()
+       return total
+
+# -------------------- Restaurant System --------------------
+class Restaurant:
+   def __init__(self):
+       self.menu = {}
+       self.order = Order()
+   def add_menu_item(self, item_type, name, price):
+       try:
+           if item_type == "VEG":
+               self.menu[name] = VegItem(name, price)
+           elif item_type == "NONVEG":
+               self.menu[name] = NonVegItem(name, price)
+           else:
+               raise ValueError("Invalid item type")
+       except Exception:
+           pass
+   def place_order(self, name):
+       try:
+           if name not in self.menu:
+               raise KeyError("Item not found")
+           self.order.add_item(self.menu[name])
+       except Exception:
+           pass
+   def cancel_order(self, name):
+       self.order.remove_item(name)
+   def get_bill(self):
+       return self.order.calculate_total()
+
+# -------------------- Switch Case Controller --------------------
+def process_commands(commands):
+   restaurant = Restaurant()
+   result = []
+   for command in commands:
+       try:
+           parts = command.split()
+           action = parts[0]
+           match action:
+               case "ADD_MENU":
+                   item_type = parts[1]
+                   name = parts[2]
+                   price = int(parts[3])
+                   restaurant.add_menu_item(item_type, name, price)
+               case "ORDER":
+                   name = parts[1]
+                   restaurant.place_order(name)
+               case "CANCEL":
+                   name = parts[1]
+                   restaurant.cancel_order(name)
+               case "BILL":
+                   result.append(str(restaurant.get_bill()))
+               case _:
+                   pass
+       except Exception:
+           pass
+   return result
+
+# -------------------- Main Execution --------------------
+if __name__ == "__main__":
+   n = int(input())
+   commands = []
+   for _ in range(n):
+       commands.append(input())
+   output = process_commands(commands)
+   for value in output:
+       print(value)

package/pods/sudo/das.txt

@@ -0,0 +1,635 @@
+dsa
+
+1.(sum of valid numbers)
+
+problem Description
+You are given an integer N.
+
+A number x (1 ≤ x ≤ N) is called a valid number if it satisfies all the following number-theoretic properties:
+
+-----------------------CODE-------------------------
+
+MOD = 10**9 + 7
+ 
+def is_valid(x):
+
+    if x % 3 != 0:
+
+        return False
+
+    if x % 5 == 0:
+
+        return False
+
+    digit_sum = sum(map(int, str(x)))
+
+    return digit_sum % 2 == 0
+ 
+def count_valid(prefix):
+
+    return prefix_valid_count[prefix]
+ 
+def build_prefix(n):
+
+    for i in range(1, n + 1):
+
+        prefix_valid_count[i] = prefix_valid_count[i - 1]
+
+        prefix_valid_sum[i] = prefix_valid_sum[i - 1]
+ 
+        if is_valid(i):
+
+            prefix_valid_count[i] += 1
+
+            prefix_valid_sum[i] = (prefix_valid_sum[i] + i) % MOD
+ 
+# Input
+
+N, K = map(int, input().split())
+ 
+prefix_valid_count = [0] * (N + 1)
+
+prefix_valid_sum = [0] * (N + 1)
+ 
+# Prefix Sum Preprocessing
+
+build_prefix(N)
+ 
+# Binary Search to find smallest X with >= K valid numbers
+
+left, right = 1, N
+
+answer = -1
+ 
+while left <= right:
+
+    mid = (left + right) // 2
+
+    if prefix_valid_count[mid] >= K:
+
+        answer = mid
+
+        right = mid - 1  # greedy minimization
+
+    else:
+
+        left = mid + 1
+ 
+# Output sum modulo
+
+print(prefix_valid_sum[answer] % MOD)
+
+-----------------------------------------------------------------------------------------
+
+
+(Tourist groups and Buses)
+
+
+def min_days_to_finish_trips(A, B, C, D):
+
+    M = len(A)
+
+    N = len(B)
+
+    # Sort groups descending (largest first)
+
+    A.sort(reverse=True)
+
+    # Pair buses as (capacity, cost) and sort by:
+
+    # 1) capacity descending
+
+    # 2) cost ascending
+
+    buses = sorted(zip(B, C), key=lambda x: (-x[0], x[1]))
+
+    # Early impossible check: largest group > largest bus capacity
+
+    if A[0] > buses[0][0]:
+
+        return -1
+
+    # Helper function: check if X days is possible
+
+    def can_finish_in_days(X):
+
+        # How many buses are minimally required
+
+        required_buses = (M + X - 1) // X
+
+        selected_buses = []
+
+        total_cost = 0
+
+        # Pick cheapest buses with highest capacity
+
+        for cap, cost in buses:
+
+            selected_buses.append(cap)
+
+            total_cost += cost
+
+            if len(selected_buses) == required_buses:
+
+                break
+
+        # Budget exceeded or not enough buses
+
+        if len(selected_buses) < required_buses or total_cost > D:
+
+            return False
+
+        # Each bus can serve X groups
+
+        slots = []
+
+        for cap in selected_buses:
+
+            slots.extend([cap] * X)
+
+        # Assign largest groups first
+
+        slots.sort()
+
+        idx = 0
+
+        for group in A:
+
+            # Find first slot that can fit this group
+
+            while idx < len(slots) and slots[idx] < group:
+
+                idx += 1
+
+            if idx == len(slots):
+
+                return False
+
+            idx += 1
+
+        return True
+
+    # Binary search on days
+
+    left, right = 1, M
+
+    answer = -1
+
+    while left <= right:
+
+        mid = (left + right) // 2
+
+        if can_finish_in_days(mid):
+
+            answer = mid
+
+            right = mid - 1
+
+        else:
+
+            left = mid + 1
+
+    return answer
+
+-----------------------------------------------------------------------------------------
+
+(Play with stacks)
+
+def play_with_stacks(s):
+   stack = []
+   removals = 0
+   for ch in s:
+       if ch == '(':
+           stack.append(ch)
+       else:
+           if stack:
+               stack.pop()
+           else:
+               removals += 1
+   removals += len(stack)
+   return removals
+
+# ---------------- TEST CASES ---------------- #
+tests = [
+   "(()))(",
+   "()()",
+   "(((",
+   ")))",
+   "()(()",
+   "((()))",
+   "(()()("
+]
+for i, t in enumerate(tests, 1):
+   print(f"Test {i}: {t} -> {play_with_stacks(t)}")
+
+
+-----------------------------------------------------------------------------------------
+
+(Distinct sets)
+
+
+def distinct_sets(arr1, arr2):
+   set1 = set(arr1)
+   set2 = set(arr2)
+   common = set1 & set2
+   return len(common)
+
+# ---------------- TEST CASES ---------------- #
+tests = [
+   ([1, 2, 3], [3, 4, 5]),
+   ([1, 1, 2], [2, 2, 3]),
+   ([5, 6], [7, 8]),
+   ([1, 2, 3], [1, 2, 3]),
+   ([10, 20], [20, 30]),
+]
+for i, (a, b) in enumerate(tests, 1):
+   print(f"Test {i}: {distinct_sets(a, b)}")
+
+
+-----------------------------------------------------------------------------------------
+
+(We will meet again)
+
+
+def can_meet(pos, dist, k):
+   count = 1
+   last = pos[0]
+   for i in range(1, len(pos)):
+       if pos[i] - last > dist:
+           count += 1
+           last = pos[i]
+           if count > k:
+               return False
+   return True
+
+def we_will_meet_again(pos, k):
+   pos.sort()
+   low, high = 0, pos[-1] - pos[0]
+   ans = high
+   while low <= high:
+       mid = (low + high) // 2
+       if can_meet(pos, mid, k):
+           ans = mid
+           high = mid - 1
+       else:
+           low = mid + 1
+   return ans
+
+# ---------------- TEST CASES ---------------- #
+tests = [
+   ([1, 2, 4, 8, 9], 3),
+   ([10, 20, 30], 2),
+   ([1, 100, 200], 2),
+   ([5, 10, 15, 20], 4),
+   ([1, 2, 3, 4, 5], 1)
+]
+for i, (pos, k) in enumerate(tests, 1):
+   print(f"Test {i}: {we_will_meet_again(pos, k)}")
+
+-----------------------------------------------------------------------------------------
+
+(Collect the prizes)
+
+
+def can_collect(prizes, k, dist):
+   collectors = 1
+   start = prizes[0]
+   for i in range(1, len(prizes)):
+       if prizes[i] - start > dist:
+           collectors += 1
+           start = prizes[i]
+           if collectors > k:
+               return False
+   return True
+
+def collect_the_prizes(prizes, k):
+   prizes.sort()
+   low, high = 0, prizes[-1] - prizes[0]
+   ans = high
+   while low <= high:
+       mid = (low + high) // 2
+       if can_collect(prizes, k, mid):
+           ans = mid
+           high = mid - 1
+       else:
+           low = mid + 1
+   return ans
+
+# -------- TEST CASES -------- #
+tests = [
+   ([1, 2, 4, 8, 9], 3),
+   ([10, 20, 30, 40], 2),
+   ([1, 100, 200], 2),
+   ([5, 6, 7, 8], 1),
+   ([1, 2, 3, 4], 4)
+]
+for i, (p, k) in enumerate(tests, 1):
+   print(f"Test {i}: {collect_the_prizes(p, k)}")
+
+-----------------------------------------------------------------------------------------
+
+(Fadi’s Garden)
+
+
+def can_water(plants, k, length):
+   sprinklers = 1
+   cover_end = plants[0] + length
+   for p in plants:
+       if p > cover_end:
+           sprinklers += 1
+           cover_end = p + length
+           if sprinklers > k:
+               return False
+   return True
+
+def fadi_garden(plants, k):
+   plants.sort()
+   low, high = 0, plants[-1] - plants[0]
+   ans = high
+   while low <= high:
+       mid = (low + high) // 2
+       if can_water(plants, k, mid):
+           ans = mid
+           high = mid - 1
+       else:
+           low = mid + 1
+   return ans
+
+# -------- TEST CASES -------- #
+tests = [
+   ([1, 2, 3, 7, 8], 2),
+   ([10, 20, 30], 1),
+   ([1, 5, 9], 3),
+   ([2, 4, 6, 8], 2),
+   ([1, 100, 200], 2)
+]
+for i, (p, k) in enumerate(tests, 1):
+   print(f"Test {i}: {fadi_garden(p, k)}")
+
+-----------------------------------------------------------------------------------------
+
+(Collecting Candies)
+
+def can_distribute(candies, k, x):
+
+    kids = 0
+
+    for c in candies:
+
+        kids += c // x
+
+    return kids >= k
+
+
+def collecting_candies(candies, k):
+
+    low, high = 1, max(candies)
+
+    ans = 0
+
+    while low <= high:
+
+        mid = (low + high) // 2
+
+        if can_distribute(candies, k, mid):
+
+            ans = mid
+
+            low = mid + 1
+
+        else:
+
+            high = mid - 1
+
+    return ans
+
+
+# -------- TEST CASES -------- #
+
+tests = [
+
+    ([10, 20, 30], 6),
+
+    ([5, 8, 6], 5),
+
+    ([100], 10),
+
+    ([4, 4, 4], 4),
+
+    ([1, 2, 3], 3)
+
+]
+
+for i, (c, k) in enumerate(tests, 1):
+
+    print(f"Test {i}: {collecting_candies(c, k)}")
+ 
+ -----------------------------------------------------------------------------------------
+
+(Its snowing)
+
+def can_clear(snow, k, d):
+
+    plows = 1
+
+    start = snow[0]
+
+    for i in range(1, len(snow)):
+
+        if snow[i] - start > d:
+
+            plows += 1
+
+            start = snow[i]
+
+            if plows > k:
+
+                return False
+
+    return True
+
+
+def its_snowing(snow, k):
+
+    snow.sort()
+
+    low, high = 0, snow[-1] - snow[0]
+
+    ans = high
+
+    while low <= high:
+
+        mid = (low + high) // 2
+
+        if can_clear(snow, k, mid):
+
+            ans = mid
+
+            high = mid - 1
+
+        else:
+
+            low = mid + 1
+
+    return ans
+
+
+# -------- TEST CASES -------- #
+
+tests = [
+
+    ([1, 2, 5, 8, 10], 2),
+
+    ([10, 20, 30], 1),
+
+    ([1, 100, 200], 2),
+
+    ([5, 6, 7, 8], 4),
+
+    ([1, 2, 3, 4], 1)
+
+]
+
+for i, (s, k) in enumerate(tests, 1):
+
+    print(f"Test {i}: {its_snowing(s, k)}")
+
+--------------------------------------------------------------------------------------
+
+(Vanish the multiset)
+
+
+from collections import Counter
+
+def vanish_multiset(arr):
+
+    freq = Counter(arr)
+
+    return len(freq)
+
+
+# -------- TEST CASES -------- #
+
+tests = [
+
+    [1, 2, 3],
+
+    [1, 1, 2, 2],
+
+    [5, 5, 5],
+
+    [1, 2, 2, 3, 3, 3],
+
+    []
+
+]
+
+for i, t in enumerate(tests, 1):
+
+    print(f"Test {i}: {vanish_multiset(t)}")
+
+--------------------------------------------------------------------------------------
+
+(Stewie Loves Pancakes)
+
+
+def can_make(pancakes, k, size):
+
+    count = 0
+
+    for p in pancakes:
+
+        count += p // size
+
+    return count >= k
+
+
+def stewie_loves_pancakes(pancakes, k):
+
+    low, high = 1, max(pancakes)
+
+    ans = 0
+
+    while low <= high:
+
+        mid = (low + high) // 2
+
+        if can_make(pancakes, k, mid):
+
+            ans = mid
+
+            low = mid + 1
+
+        else:
+
+            high = mid - 1
+
+    return ans
+
+
+# -------- TEST CASES -------- #
+
+tests = [
+
+    ([10, 20, 30], 6),
+
+    ([5, 8, 6], 5),
+
+    ([100], 10),
+
+    ([4, 4, 4], 4),
+
+    ([1, 2, 3], 3)
+
+]
+
+for i, (p, k) in enumerate(tests, 1):
+
+    print(f"Test {i}: {stewie_loves_pancakes(p, k)}")
+
+--------------------------------------------------------------------------------------
+
+(Number of Emirp)
+
+def sieve(n):
+
+    prime = [True] * (n + 1)
+
+    prime[0] = prime[1] = False
+
+    for i in range(2, int(n ** 0.5) + 1):
+
+        if prime[i]:
+
+            for j in range(i * i, n + 1, i):
+
+                prime[j] = False
+
+    return prime
+
+
+def count_emirp(n):
+
+    prime = sieve(n)
+
+    count = 0
+
+    for i in range(13, n + 1):
+
+        rev = int(str(i)[::-1])
+
+        if i != rev and prime[i] and rev <= n and prime[rev]:
+
+            count += 1
+
+    return count
+
+
+# -------- TEST CASES -------- #
+
+tests = [50, 100, 500, 1000, 2000]
+
+for i, n in enumerate(tests, 1):
+
+    print(f"Test {i}: N={n} -> {count_emirp(n)}")
+