solutions

Author: vikahaze

solutions/3577/01.py

@@ -0,0 +1,25 @@
+from typing import List
+
+
+class Solution:
+    def countPermutations(self, complexity: List[int]) -> int:
+        MOD = 10**9 + 7
+
+        n = len(complexity)
+
+        # Check if complexity[0] is the unique minimum
+        min_complexity = complexity[0]
+        min_count = sum(1 for c in complexity if c == min_complexity)
+
+        if min_count > 1:
+            # If there are other elements with the same complexity as index 0, no valid permutations
+            return 0
+
+        # Index 0 must be first. The remaining n-1 indices can be arranged in any order
+        # So the answer is (n-1)!
+        res = 1
+        for i in range(1, n):
+            res = (res * i) % MOD
+
+        return res
+

solutions/3724/01.py

@@ -1,30 +1,26 @@
+from typing import List
+
+
 class Solution:
     def minOperations(self, nums1: List[int], nums2: List[int]) -> int:
         n = len(nums1)
-        res = float('inf')
-        
-        # nums2 has one extra element, which must come from appending
+        res = float("inf")
+
+        # nums2 has n+1 elements, so one element must come from an append operation
         # Try each index j in nums1 as the one to append
         for j in range(n):
             # Cost to make nums1[j] match both nums2[j] and nums2[-1]
-            # We need to adjust nums1[j] to one value, then append it
-            # The cost is: |nums1[j] - nums2[j]| + |nums1[j] - nums2[-1]|
-            # But we can optimize: make nums1[j] equal to one, then adjust the appended copy
-            # Actually, we can make one copy nums2[j] and one copy nums2[-1]
-            # Cost = |nums1[j] - nums2[j]| + |nums1[j] - nums2[-1]|
-            # But wait, we append first, then adjust. So:
-            # 1. Append nums1[j] (cost 0 for append operation itself)
-            # 2. Adjust original to nums2[j]: |nums1[j] - nums2[j]|
-            # 3. Adjust appended to nums2[-1]: |nums1[j] - nums2[-1]|
-            
-            cost = abs(nums1[j] - nums2[j]) + abs(nums1[j] - nums2[-1])
-            
+            # We need: one copy becomes nums2[j], appended copy becomes nums2[-1]
+            # The cost is |nums1[j] - nums2[j]| + |nums1[j] - nums2[-1]|
+            append_cost = abs(nums1[j] - nums2[j]) + abs(nums1[j] - nums2[-1])
+
             # Cost to transform all other positions
+            other_cost = 0
             for i in range(n):
                 if i != j:
-                    cost += abs(nums1[i] - nums2[i])
-            
-            res = min(res, cost)
-        
-        return res
+                    other_cost += abs(nums1[i] - nums2[i])
+
+            total_cost = append_cost + other_cost
+            res = min(res, total_cost)
 
+        return res

solutions/3728/01.py

@@ -1,37 +1,24 @@
+from typing import List
+
+
 class Solution:
     def countStableSubarrays(self, capacity: List[int]) -> int:
         n = len(capacity)
-        
-        # Compute prefix sums
+        res = 0
+
+        # Build prefix sum
         prefix = [0] * (n + 1)
         for i in range(n):
             prefix[i + 1] = prefix[i] + capacity[i]
-        
-        res = 0
-        
-        # For each right endpoint r, find valid left endpoints l
-        # Condition: capacity[l] == capacity[r] and
-        # capacity[l] == sum(capacity[l+1:r])
-        # Which means: capacity[l] == prefix[r] - prefix[l+1]
-        # Rearranging: prefix[l+1] == prefix[r] - capacity[r]
-        
-        # Use a map: (value, prefix_sum) -> count
-        from collections import defaultdict
-        freq_map = defaultdict(int)
-        
-        # Process from left to right
-        for r in range(n):
-            # For each r, we want to find l such that:
-            # capacity[l] == capacity[r] and prefix[l+1] == prefix[r] - capacity[r]
-            target_prefix = prefix[r] - capacity[r]
-            key = (capacity[r], target_prefix)
-            res += freq_map[key]
-            
-            # Update map: add (capacity[r], prefix[r]) for future matches
-            # Note: we use prefix[r] (not prefix[r+1]) because when we check at position r,
-            # we're looking for l where prefix[l+1] matches
-            update_key = (capacity[r], prefix[r])
-            freq_map[update_key] += 1
-        
-        return res
 
+        # For each subarray [l, r] where length >= 3
+        # Check if capacity[l] == capacity[r] == sum of elements between them
+        for l in range(n):
+            for r in range(l + 2, n):  # length >= 3
+                if capacity[l] == capacity[r]:
+                    # Sum of elements strictly between l and r
+                    interior_sum = prefix[r] - prefix[l + 1]
+                    if capacity[l] == interior_sum:
+                        res += 1
+
+        return res

solutions/3733/01.py

@@ -0,0 +1,39 @@
+from typing import List
+import math
+
+
+class Solution:
+    def minimumTime(self, d: List[int], r: List[int]) -> int:
+        d1, d2 = d[0], d[1]
+        r1, r2 = r[0], r[1]
+
+        # Binary search on total time T
+        def can_complete(T):
+            # Calculate available hours for each drone
+            # Drone 1: T - floor(T/r1) hours available (subtract recharge hours)
+            avail1 = T - (T // r1)
+            avail2 = T - (T // r2)
+
+            # Hours when both are recharging (unavailable)
+            lcm_r = math.lcm(r1, r2)
+            both_recharging = T // lcm_r
+
+            # Shared available hours (when at least one is available)
+            shared = T - both_recharging
+
+            # Check if we can complete all deliveries
+            # Each drone needs its deliveries, and they can't overlap in time
+            # We need: avail1 >= d1 and avail2 >= d2, and total available >= d1 + d2
+            return avail1 >= d1 and avail2 >= d2 and shared >= d1 + d2
+
+        # Binary search
+        left, right = 1, 10**18
+        while left < right:
+            mid = (left + right) // 2
+            if can_complete(mid):
+                right = mid
+            else:
+                left = mid + 1
+
+        return left
+

solutions/3747/01.py

@@ -1,22 +1,22 @@
 class Solution:
-    def beautifulSubstrings(self, s: str, k: int) -> int:
-        vowels = {'a', 'e', 'i', 'o', 'u'}
-        n = len(s)
-        res = 0
-        
-        # Try all possible substrings
-        for i in range(n):
-            vowel_count = 0
-            consonant_count = 0
-            
-            for j in range(i, n):
-                if s[j] in vowels:
-                    vowel_count += 1
-                else:
-                    consonant_count += 1
-                
-                # Check if beautiful
-                if vowel_count == consonant_count and (vowel_count * consonant_count) % k == 0:
-                    res += 1
-        
-        return res
+    def countDistinct(self, n: int) -> int:
+        # For each integer x from 1 to n, remove zeros and count distinct results
+        distinct_set = set()
+
+        for x in range(1, n + 1):
+            # Remove zeros from decimal representation
+            s = str(x)
+            s_no_zeros = s.replace("0", "")
+            if s_no_zeros:  # If not empty after removing zeros
+                distinct_set.add(int(s_no_zeros))
+            else:
+                # If all zeros, the result is empty, but we can represent it as 0 or empty
+                # Actually, removing zeros from a number with only zeros gives empty string
+                # But we need to handle this - let's check the examples
+                # For n=10: 10 -> "10" -> "1" -> 1
+                # So we should add something for numbers that become empty
+                # Actually, looking at example: n=10 gives 9 distinct (1-9), and 10 becomes 1
+                # So empty strings might not be counted, or they become 0
+                pass
+
+        return len(distinct_set)

solutions/3753/01.py

@@ -1,32 +1,22 @@
 class Solution:
-    def numberOfPaths(self, grid: List[List[int]], k: int) -> int:
-        MOD = 10**9 + 7
-        m, n = len(grid), len(grid[0])
-        
-        # dp[i][j][r] = number of paths to (i,j) with sum % k == r
-        # Use 2D DP with k states for remainder
-        dp = [[[0] * k for _ in range(n)] for _ in range(m)]
-        
-        # Initialize starting position
-        initial_remainder = grid[0][0] % k
-        dp[0][0][initial_remainder] = 1
-        
-        for i in range(m):
-            for j in range(n):
-                current_val = grid[i][j]
-                
-                # Update from top
-                if i > 0:
-                    for r in range(k):
-                        new_remainder = (r + current_val) % k
-                        dp[i][j][new_remainder] = (dp[i][j][new_remainder] + dp[i-1][j][r]) % MOD
-                
-                # Update from left
-                if j > 0:
-                    for r in range(k):
-                        new_remainder = (r + current_val) % k
-                        dp[i][j][new_remainder] = (dp[i][j][new_remainder] + dp[i][j-1][r]) % MOD
-        
-        # Return paths to (m-1, n-1) with remainder 0
-        return dp[m-1][n-1][0]
+    def totalWaviness(self, num1: int, num2: int) -> int:
+        def get_waviness(n):
+            s = str(n)
+            if len(s) < 3:
+                return 0
 
+            waviness = 0
+            for i in range(1, len(s) - 1):
+                # Check if digit at i is a peak or valley
+                if s[i] > s[i - 1] and s[i] > s[i + 1]:
+                    waviness += 1  # Peak
+                elif s[i] < s[i - 1] and s[i] < s[i + 1]:
+                    waviness += 1  # Valley
+
+            return waviness
+
+        res = 0
+        for num in range(num1, num2 + 1):
+            res += get_waviness(num)
+
+        return res

solutions/3769/01.py

@@ -0,0 +1,15 @@
+from typing import List
+
+
+class Solution:
+    def sortByReflection(self, nums: List[int]) -> List[int]:
+        def binary_reflection(n):
+            # Convert to binary, remove '0b' prefix, reverse, convert back to int
+            binary = bin(n)[2:]
+            reversed_binary = binary[::-1]
+            return int(reversed_binary, 2)
+
+        # Sort by binary reflection, then by original value if reflection is equal
+        res = sorted(nums, key=lambda x: (binary_reflection(x), x))
+        return res
+