chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-12-10-3577-Count-the-Number-of-Computer-Unlocking-Permutations/explanation.md

@@ -0,0 +1,48 @@
+# Count the Number of Computer Unlocking Permutations (Medium)
+
+**Problem ID:** 3577  
+**Date:** 2025-12-10  
+**Link:** https://leetcode.com/problems/count-the-number-of-computer-unlocking-permutations/
+
+## Approach
+
+To solve the problem of counting the number of valid unlocking permutations of computers based on their complexities, we can follow a systematic approach leveraging combinatorial mathematics and dynamic programming.
+
+### Problem Breakdown:
+1. **Understanding Unlocking Conditions**: 
+   - Computer 0 is always unlocked first.
+   - A computer `i` can only be unlocked if there exists a previously unlocked computer `j` (where `j < i`) such that `complexity[j] < complexity[i]`.
+
+2. **Permutations and Validity**:
+   - The task is to count the valid permutations of the array `[0, 1, 2, ..., n-1]` where the unlocking conditions are satisfied.
+
+### Approach:
+1. **Sorting and Grouping**:
+   - First, we need to analyze the complexities. Sort the computers based on their complexities while keeping track of their original indices. This helps in understanding which computers can unlock which others.
+
+2. **Dynamic Programming Setup**:
+   - Use a dynamic programming array `dp[i]` to represent the number of valid ways to unlock the first `i` computers.
+   - Initialize `dp[0] = 1` since there is only one way to start with computer 0 unlocked.
+
+3. **Counting Valid Unlocks**:
+   - For each computer `i`, determine the number of computers that can unlock it by looking back at the previously unlocked computers. This is done by checking the sorted complexities.
+   - For each unique complexity, maintain a cumulative count of how many computers have been unlocked up to that point.
+
+4. **Combinatorial Counting**:
+   - For each computer `i`, if it can be unlocked by `k` previous computers, the number of ways to arrange the unlocking of these `k` computers can be calculated using combinations.
+   - The total count of valid permutations can be derived by multiplying the number of ways to choose and arrange the computers that can unlock `i`.
+
+5. **Modular Arithmetic**:
+   - Since the answer can be large, use modular arithmetic (modulo \(10^9 + 7\)) throughout the calculations to avoid overflow and to meet problem constraints.
+
+### Data Structures:
+- An array to store the complexities.
+- A sorted version of the complexities to facilitate the unlocking condition checks.
+- A dynamic programming array to keep track of the number of valid unlocking sequences.
+
+### Complexity:
+- **Time Complexity**: The overall complexity is \(O(n \log n)\) due to the sorting step, followed by a linear pass through the complexities to calculate valid permutations.
+- **Space Complexity**: \(O(n)\) for storing the dynamic programming array and any auxiliary structures used for counting.
+
+### Conclusion:
+By combining sorting, dynamic programming, and combinatorial counting, we can effectively count the number of valid unlocking permutations of the computers based on their complexities. This approach efficiently handles the constraints given in the problem statement.

Medium/2025-12-10-3577-Count-the-Number-of-Computer-Unlocking-Permutations/solution.java

@@ -0,0 +1,33 @@
+import java.util.Arrays;
+
+public class Solution {
+    private static final int MOD = 1000000007;
+
+    public int countOrders(int[] complexity) {
+        int n = complexity.length;
+        Arrays.sort(complexity);
+        
+        long[] dp = new long[n + 1];
+        dp[0] = 1; // Base case: 1 way to unlock 0 computers
+        
+        for (int i = 1; i <= n; i++) {
+            long count = 0;
+            for (int j = 0; j < i; j++) {
+                if (complexity[j] < complexity[i - 1]) {
+                    count = (count + dp[j]) % MOD;
+                }
+            }
+            dp[i] = count * factorial(i - 1) % MOD;
+        }
+        
+        return (int) dp[n];
+    }
+
+    private long factorial(int x) {
+        long result = 1;
+        for (int i = 2; i <= x; i++) {
+            result = (result * i) % MOD;
+        }
+        return result;
+    }
+}

Medium/2025-12-10-3577-Count-the-Number-of-Computer-Unlocking-Permutations/solution.js

@@ -0,0 +1,24 @@
+var countOrders = function(complexity) {
+    const MOD = 1e9 + 7;
+    const n = complexity.length;
+    complexity.sort((a, b) => a - b);
+    
+    let dp = new Array(n + 1).fill(0);
+    dp[0] = 1;
+    
+    for (let i = 1; i <= n; i++) {
+        let count = 0;
+        for (let j = 0; j < i; j++) {
+            if (complexity[j] < complexity[i - 1]) {
+                count++;
+            }
+        }
+        dp[i] = (dp[i - 1] * count) % MOD;
+    }
+    
+    return dp[n];
+};
+
+// Example test cases
+console.log(countOrders([1, 2, 3])); // Output: 2
+console.log(countOrders([3, 3, 3, 4, 4, 4])); // Output: 0

Medium/2025-12-10-3577-Count-the-Number-of-Computer-Unlocking-Permutations/solution.py

@@ -0,0 +1,27 @@
+class Solution:
+    def countOrders(self, complexity: List[int]) -> int:
+        MOD = 10**9 + 7
+        n = len(complexity)
+        
+        # Sort the complexity with their original indices
+        indexed_complexity = sorted((c, i) for i, c in enumerate(complexity))
+        
+        # dp[i] will store the number of valid permutations for the first i computers
+        dp = [0] * (n + 1)
+        dp[0] = 1  # Base case: 1 way to unlock 0 computers
+        
+        # Count how many computers have the same complexity
+        count = [0] * (n + 1)
+        
+        for i in range(1, n + 1):
+            c, idx = indexed_complexity[i - 1]
+            count[i] = count[i - 1]
+            # Count how many computers have complexity less than the current
+            for j in range(i):
+                if indexed_complexity[j][0] < c:
+                    count[i] += 1
+            
+            # Calculate the number of valid permutations
+            dp[i] = dp[i - 1] * count[i] % MOD
+        
+        return dp[n]

README.md

@@ -300,3 +300,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-12-07 — [Count Odd Numbers in an Interval Range](https://leetcode.com/problems/count-odd-numbers-in-an-interval-range/) (Easy) → `Easy/2025-12-07-1523-Count-Odd-Numbers-in-an-Interval-Range`
 - 2025-12-08 — [Count Square Sum Triples](https://leetcode.com/problems/count-square-sum-triples/) (Easy) → `Easy/2025-12-08-1925-Count-Square-Sum-Triples`
 - 2025-12-09 — [Count Special Triplets](https://leetcode.com/problems/count-special-triplets/) (Medium) → `Medium/2025-12-09-3583-Count-Special-Triplets`
+- 2025-12-10 — [Count the Number of Computer Unlocking Permutations](https://leetcode.com/problems/count-the-number-of-computer-unlocking-permutations/) (Medium) → `Medium/2025-12-10-3577-Count-the-Number-of-Computer-Unlocking-Permutations`