chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-01-04-1390-Four-Divisors/explanation.md

@@ -0,0 +1,39 @@
+# Four Divisors (Medium)
+
+**Problem ID:** 1390  
+**Date:** 2026-01-04  
+**Link:** https://leetcode.com/problems/four-divisors/
+
+## Approach
+
+To solve the "Four Divisors" problem, we need to identify integers in the given array that have exactly four divisors and compute the sum of those divisors. Here's a structured approach to tackle this problem:
+
+### Main Idea:
+1. **Understanding Divisors**: An integer has exactly four divisors if it can be expressed in one of two forms:
+   - A product of two distinct prime numbers, \( p \times q \), where \( p \) and \( q \) are prime. The divisors in this case are \( 1, p, q, \) and \( p \times q \).
+   - A cube of a prime number, \( p^3 \), where the divisors are \( 1, p, p^2, \) and \( p^3 \).
+
+2. **Efficient Prime Generation**: Since the maximum value for elements in `nums` is \( 10^5 \), we can use the Sieve of Eratosthenes to generate all prime numbers up to \( 10^5 \). This allows us to quickly check if a number is prime and to find its divisors.
+
+### Steps:
+1. **Generate Primes**: Use the Sieve of Eratosthenes to create a list of all primes up to \( 10^5 \) and store them in a set for O(1) lookups.
+
+2. **Iterate through the Array**: For each number in the `nums` array:
+   - Check if it has exactly four divisors:
+     - **Form 1**: Check if it can be expressed as \( p \times q \) where both \( p \) and \( q \) are distinct primes. If found, compute the sum of divisors \( 1 + p + q + (p \times q) \).
+     - **Form 2**: Check if it is of the form \( p^3 \) for some prime \( p \). If so, compute the sum of divisors \( 1 + p + p^2 + p^3 \).
+
+3. **Accumulate Results**: Maintain a running total of the sums of divisors for all numbers that meet the criteria.
+
+4. **Return the Result**: After processing all numbers, return the accumulated sum. If no numbers had exactly four divisors, return 0.
+
+### Data Structures:
+- A list or array to hold the prime numbers generated by the sieve.
+- A set for quick prime checks.
+- A variable to accumulate the sum of divisors.
+
+### Complexity:
+- **Time Complexity**: The Sieve of Eratosthenes runs in \( O(n \log \log n) \) where \( n \) is \( 10^5 \). Checking each number in `nums` requires factorization that, in the worst case, can be handled in \( O(\sqrt{m}) \) where \( m \) is the number being checked, leading to an overall complexity of \( O(n \sqrt{m}) \) for the entire array.
+- **Space Complexity**: The space used for the sieve is \( O(n) \) for storing primes.
+
+This approach efficiently identifies numbers with exactly four divisors and calculates their divisor sums, adhering to the constraints provided in the problem statement.

Medium/2026-01-04-1390-Four-Divisors/solution.java

@@ -0,0 +1,25 @@
+class Solution {
+    public int sumFourDivisors(int[] nums) {
+        int sum = 0;
+        for (int num : nums) {
+            int count = 0;
+            int divisorSum = 0;
+            for (int i = 1; i * i <= num; i++) {
+                if (num % i == 0) {
+                    if (i * i == num) {
+                        count++;
+                        divisorSum += i;
+                    } else {
+                        count += 2;
+                        divisorSum += i + (num / i);
+                    }
+                }
+                if (count > 4) break;
+            }
+            if (count == 4) {
+                sum += divisorSum;
+            }
+        }
+        return sum;
+    }
+}

Medium/2026-01-04-1390-Four-Divisors/solution.js

@@ -0,0 +1,26 @@
+var sumFourDivisors = function(nums) {
+    let totalSum = 0;
+
+    const hasFourDivisors = (n) => {
+        let divisors = [];
+        for (let i = 1; i * i <= n; i++) {
+            if (n % i === 0) {
+                divisors.push(i);
+                if (i !== n / i) {
+                    divisors.push(n / i);
+                }
+            }
+            if (divisors.length > 4) return null;
+        }
+        return divisors.length === 4 ? divisors.reduce((a, b) => a + b) : null;
+    };
+
+    for (const num of nums) {
+        const sum = hasFourDivisors(num);
+        if (sum) {
+            totalSum += sum;
+        }
+    }
+
+    return totalSum;
+};

Medium/2026-01-04-1390-Four-Divisors/solution.py

@@ -0,0 +1,18 @@
+class Solution:
+    def sumFourDivisors(self, nums: List[int]) -> int:
+        def get_divisors_sum(n):
+            divisors = []
+            for i in range(1, int(n**0.5) + 1):
+                if n % i == 0:
+                    divisors.append(i)
+                    if i != n // i:
+                        divisors.append(n // i)
+                if len(divisors) > 4:
+                    return 0
+            return sum(divisors) if len(divisors) == 4 else 0
+        
+        total_sum = 0
+        for num in nums:
+            total_sum += get_divisors_sum(num)
+        
+        return total_sum

README.md

@@ -325,3 +325,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-01-01 — [Plus One](https://leetcode.com/problems/plus-one/) (Easy) → `Easy/2026-01-01-66-Plus-One`
 - 2026-01-02 — [N-Repeated Element in Size 2N Array](https://leetcode.com/problems/n-repeated-element-in-size-2n-array/) (Easy) → `Easy/2026-01-02-961-N-Repeated-Element-in-Size-2N-Array`
 - 2026-01-03 — [Number of Ways to Paint N × 3 Grid](https://leetcode.com/problems/number-of-ways-to-paint-n-3-grid/) (Hard) → `Hard/2026-01-03-1411-Number-of-Ways-to-Paint-N-3-Grid`
+- 2026-01-04 — [Four Divisors](https://leetcode.com/problems/four-divisors/) (Medium) → `Medium/2026-01-04-1390-Four-Divisors`