chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-12-15-2110-Number-of-Smooth-Descent-Periods-of-a-Stock/explanation.md

@@ -0,0 +1,32 @@
+# Number of Smooth Descent Periods of a Stock (Medium)
+
+**Problem ID:** 2110  
+**Date:** 2025-12-15  
+**Link:** https://leetcode.com/problems/number-of-smooth-descent-periods-of-a-stock/
+
+## Approach
+
+To solve the problem of counting the number of smooth descent periods in a stock price history, we can utilize a straightforward approach that leverages a single pass through the array of prices.
+
+### Main Idea:
+The key observation is that a smooth descent period consists of contiguous days where each day’s price is exactly 1 less than the previous day’s price. We can keep track of these periods by maintaining a count of how many consecutive days form a smooth descent.
+
+### Approach:
+1. **Initialization**: Start by initializing a variable to store the total count of smooth descent periods (`total_periods`) and another variable to keep track of the current length of a smooth descent period (`current_length`).
+
+2. **Iterate through the prices**: Loop through the `prices` array starting from the second element:
+   - If the current price is exactly 1 less than the previous price, it indicates that we are in a smooth descent. In this case, increment the `current_length` by 1.
+   - If the condition is not satisfied (i.e., the current price is not 1 less than the previous price), reset `current_length` to 0 since the smooth descent has ended.
+
+3. **Count periods**: For each day, whether it starts a new descent or continues an existing one, add the count of smooth descent periods to `total_periods`. Each single day is also considered a valid smooth descent period, so we can add `current_length + 1` to the total periods at each step.
+
+4. **Final Count**: After iterating through the entire array, the `total_periods` will contain the total count of all smooth descent periods.
+
+### Data Structures:
+- We primarily use simple integer variables for counting (`total_periods` and `current_length`), which makes the space complexity O(1).
+
+### Complexity:
+- **Time Complexity**: O(n), where n is the length of the `prices` array, since we are making a single pass through the array.
+- **Space Complexity**: O(1), as we are using a constant amount of extra space.
+
+This efficient approach ensures that we can handle the upper constraint of the problem (up to 100,000 prices) comfortably within time limits.

Medium/2025-12-15-2110-Number-of-Smooth-Descent-Periods-of-a-Stock/solution.java

@@ -0,0 +1,18 @@
+class Solution {
+    public long getDescentPeriods(int[] prices) {
+        long count = 0;
+        int n = prices.length;
+        int currentPeriod = 1;
+
+        for (int i = 1; i < n; i++) {
+            if (prices[i] == prices[i - 1] - 1) {
+                currentPeriod++;
+            } else {
+                currentPeriod = 1;
+            }
+            count += currentPeriod;
+        }
+        
+        return count + n; // Add n for the single-day periods
+    }
+}

Medium/2025-12-15-2110-Number-of-Smooth-Descent-Periods-of-a-Stock/solution.js

@@ -0,0 +1,15 @@
+var getDescentPeriods = function(prices) {
+    let count = 0;
+    let currentPeriod = 1;
+
+    for (let i = 1; i < prices.length; i++) {
+        if (prices[i] === prices[i - 1] - 1) {
+            currentPeriod++;
+        } else {
+            currentPeriod = 1;
+        }
+        count += currentPeriod;
+    }
+
+    return count + prices.length; // Add the individual days
+};

Medium/2025-12-15-2110-Number-of-Smooth-Descent-Periods-of-a-Stock/solution.py

@@ -0,0 +1,13 @@
+class Solution:
+    def getDescentPeriods(self, prices: List[int]) -> int:
+        total_periods = len(prices)
+        current_period = 0
+        
+        for i in range(1, len(prices)):
+            if prices[i] == prices[i - 1] - 1:
+                current_period += 1
+            else:
+                current_period = 0
+            total_periods += current_period
+        
+        return total_periods

README.md

@@ -305,3 +305,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-12-12 — [Count Mentions Per User](https://leetcode.com/problems/count-mentions-per-user/) (Medium) → `Medium/2025-12-12-3433-Count-Mentions-Per-User`
 - 2025-12-13 — [Coupon Code Validator](https://leetcode.com/problems/coupon-code-validator/) (Easy) → `Easy/2025-12-13-3606-Coupon-Code-Validator`
 - 2025-12-14 — [Number of Ways to Divide a Long Corridor](https://leetcode.com/problems/number-of-ways-to-divide-a-long-corridor/) (Hard) → `Hard/2025-12-14-2147-Number-of-Ways-to-Divide-a-Long-Corridor`
+- 2025-12-15 — [Number of Smooth Descent Periods of a Stock](https://leetcode.com/problems/number-of-smooth-descent-periods-of-a-stock/) (Medium) → `Medium/2025-12-15-2110-Number-of-Smooth-Descent-Periods-of-a-Stock`