chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-04-04-2075-Decode-the-Slanted-Ciphertext/explanation.md

@@ -0,0 +1,28 @@
+# Decode the Slanted Ciphertext (Medium)
+
+**Problem ID:** 2075  
+**Date:** 2026-04-04  
+**Link:** https://leetcode.com/problems/decode-the-slanted-ciphertext/
+
+## Approach
+
+To solve the problem of decoding the slanted ciphertext, we need to reverse the encoding process described. The approach can be broken down into the following steps:
+
+1. **Understanding the Matrix Structure**: The encoded text is derived from a matrix filled in a specific order. The matrix has a fixed number of rows, and the characters from `originalText` are filled diagonally. The first step is to determine the number of columns in the matrix. This can be calculated as:
+   - `columns = (length of encodedText + rows - 1) // rows`
+   This formula ensures that we have enough columns to accommodate the entire `encodedText` when filled in the specified manner.
+
+2. **Reconstructing the Matrix**: Using the calculated number of columns, we can reconstruct the matrix from the `encodedText`. The matrix will be filled row by row, where each row will contain `columns` characters from the `encodedText`.
+
+3. **Filling the Matrix**: We fill the matrix by iterating over the `encodedText` and placing characters in their respective positions according to the diagonal filling order. This involves:
+   - For each column, starting from the top row and moving downwards, we fill the matrix diagonally until we reach the bottom row or the end of the string.
+
+4. **Extracting the Original Text**: Once the matrix is filled, we can extract the `originalText` by reading the matrix in a row-wise manner. This means concatenating characters from each row sequentially to form the final decoded string.
+
+5. **Handling Edge Cases**: We need to consider cases where `encodedText` is empty or when there is only one row, in which case the output would be the same as the input.
+
+**Data Structures**: A 2D list (matrix) is used to store the characters while reconstructing the matrix. This allows for easy access and modification of individual elements.
+
+**Complexity**: The time complexity of this approach is O(n), where n is the length of `encodedText`, as we are iterating through the string a constant number of times. The space complexity is also O(n) due to the storage of the matrix.
+
+By following this structured approach, we can efficiently decode the slanted ciphertext back to the original text.

Medium/2026-04-04-2075-Decode-the-Slanted-Ciphertext/solution.java

@@ -0,0 +1,32 @@
+class Solution {
+    public String decodeCiphertext(String encodedText, int rows) {
+        int n = encodedText.length();
+        if (n == 0 || rows == 0) return "";
+        
+        int cols = (n + rows - 1) / rows; // Calculate the number of columns
+        char[][] matrix = new char[rows][cols];
+        
+        // Fill the matrix with characters from encodedText
+        for (int i = 0; i < n; i++) {
+            int r = i % rows;
+            int c = i / rows;
+            if (c < cols) {
+                matrix[r][c] = encodedText.charAt(i);
+            }
+        }
+        
+        StringBuilder originalText = new StringBuilder();
+        
+        // Read the matrix in the slanted order
+        for (int diag = 0; diag < cols; diag++) {
+            for (int r = 0; r < rows; r++) {
+                int c = diag - r;
+                if (c >= 0 && c < cols && matrix[r][c] != '\u0000') {
+                    originalText.append(matrix[r][c]);
+                }
+            }
+        }
+        
+        return originalText.toString().trim(); // Remove trailing spaces
+    }
+}

Medium/2026-04-04-2075-Decode-the-Slanted-Ciphertext/solution.js

@@ -0,0 +1,16 @@
+var decodeCiphertext = function(encodedText, rows) {
+    const n = encodedText.length;
+    const cols = Math.ceil(n / rows);
+    let originalText = '';
+
+    for (let i = 0; i < cols; i++) {
+        for (let j = 0; j < rows; j++) {
+            const index = j + i + j * (cols - 1);
+            if (index < n) {
+                originalText += encodedText[index];
+            }
+        }
+    }
+
+    return originalText.replace(/\s+$/, '');
+};

Medium/2026-04-04-2075-Decode-the-Slanted-Ciphertext/solution.py

@@ -0,0 +1,26 @@
+class Solution:
+    def decodeCiphertext(self, encodedText: str, rows: int) -> str:
+        if rows == 0 or not encodedText:
+            return ""
+        
+        n = len(encodedText)
+        cols = (n + rows - 1) // rows
+        matrix = [[' ' for _ in range(cols)] for _ in range(rows)]
+        
+        idx = 0
+        for r in range(rows):
+            for c in range(cols):
+                if idx < n:
+                    matrix[r][c] = encodedText[idx]
+                    idx += 1
+        
+        originalText = []
+        for diag in range(cols):
+            r, c = 0, diag
+            while r < rows and c >= 0:
+                if matrix[r][c] != ' ':
+                    originalText.append(matrix[r][c])
+                r += 1
+                c -= 1
+        
+        return ''.join(originalText).rstrip()

README.md

@@ -413,3 +413,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-04-01 — [Robot Collisions](https://leetcode.com/problems/robot-collisions/) (Hard) → `Hard/2026-04-01-2751-Robot-Collisions`
 - 2026-04-02 — [Maximum Amount of Money Robot Can Earn](https://leetcode.com/problems/maximum-amount-of-money-robot-can-earn/) (Medium) → `Medium/2026-04-02-3418-Maximum-Amount-of-Money-Robot-Can-Earn`
 - 2026-04-03 — [Maximum Walls Destroyed by Robots](https://leetcode.com/problems/maximum-walls-destroyed-by-robots/) (Hard) → `Hard/2026-04-03-3661-Maximum-Walls-Destroyed-by-Robots`
+- 2026-04-04 — [Decode the Slanted Ciphertext](https://leetcode.com/problems/decode-the-slanted-ciphertext/) (Medium) → `Medium/2026-04-04-2075-Decode-the-Slanted-Ciphertext`