Initial commit: LeetCode solutions repository with 2 Medium problems

Author: TechnoBlogger14o3

.github/workflows/validate-structure.yml

@@ -0,0 +1,34 @@
+# GitHub Actions workflow for validating repository structure
+# This is a template for future use
+
+name: Validate Repository Structure
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v3
+      
+    - name: Validate folder structure
+      run: |
+        echo "Validating repository structure..."
+        # Add validation logic here in the future
+        echo "✅ Repository structure validation passed"
+        
+    - name: Check README format
+      run: |
+        echo "Checking README.md format..."
+        if [ -f "README.md" ]; then
+          echo "✅ README.md exists"
+        else
+          echo "❌ README.md not found"
+          exit 1
+        fi

.gitignore

@@ -0,0 +1,57 @@
+# LeetCode Solutions Repository .gitignore
+
+# IDE and Editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Compiled files
+*.class
+*.o
+*.exe
+*.out
+
+# Logs
+*.log
+
+# Temporary files
+*.tmp
+*.temp
+
+# Node modules (if using any JavaScript tools)
+node_modules/
+
+# Python cache
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+
+# Java compiled files
+*.class
+*.jar
+
+# C++ compiled files
+*.exe
+*.out
+*.o
+*.a
+*.so
+*.dylib
+
+# Backup files
+*.bak
+*.backup

Easy/2025-01-27-0001-TwoSum/explanation.md

@@ -0,0 +1,85 @@
+# Two Sum - Problem #1
+
+## Problem Statement
+Given an array of integers `nums` and an integer `target`, return indices of the two numbers such that they add up to `target`.
+
+You may assume that each input would have exactly one solution, and you may not use the same element twice.
+
+You can return the answer in any order.
+
+## Examples
+```
+Input: nums = [2,7,11,15], target = 9
+Output: [0,1]
+Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
+
+Input: nums = [3,2,4], target = 6
+Output: [1,2]
+
+Input: nums = [3,3], target = 6
+Output: [0,1]
+```
+
+## Approach
+**Hash Map Approach:**
+1. Use a HashMap to store each number and its index
+2. For each number, calculate the complement (target - current_number)
+3. If complement exists in HashMap, we found our pair
+4. Otherwise, add current number and its index to HashMap
+
+## Complexity Analysis
+- **Time Complexity**: O(n) - Single pass through the array
+- **Space Complexity**: O(n) - HashMap to store numbers and indices
+
+## Key Insights
+- Using HashMap allows O(1) lookup time for complements
+- Single pass solution is more efficient than nested loops
+- Trade-off: extra space for better time complexity
+
+## Alternative Approaches
+1. **Brute Force**: O(n²) time, O(1) space
+2. **Two Pointers**: Requires sorted array, O(n log n) time
+
+## Solutions in Different Languages
+
+### Java
+```java
+// See solution.java
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> map = new HashMap<>();
+        
+        for (int i = 0; i < nums.length; i++) {
+            int complement = target - nums[i];
+            
+            if (map.containsKey(complement)) {
+                return new int[] {map.get(complement), i};
+            }
+            
+            map.put(nums[i], i);
+        }
+        
+        return new int[] {}; // No solution found
+    }
+}
+```
+
+### JavaScript
+```javascript
+// See solution.js
+var twoSum = function(nums, target) {
+    const map = new Map();
+    
+    for (let i = 0; i < nums.length; i++) {
+        const complement = target - nums[i];
+        
+        if (map.has(complement)) {
+            return [map.get(complement), i];
+        }
+        
+        map.set(nums[i], i);
+    }
+    
+    return []; // No solution found
+};
+```

Easy/2025-01-27-0001-TwoSum/solution.java

@@ -0,0 +1,24 @@
+// Solution for LeetCode Problem #1: Two Sum
+// Date: 2025-01-27
+// Difficulty: Easy
+
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> map = new HashMap<>();
+        
+        for (int i = 0; i < nums.length; i++) {
+            int complement = target - nums[i];
+            
+            if (map.containsKey(complement)) {
+                return new int[] {map.get(complement), i};
+            }
+            
+            map.put(nums[i], i);
+        }
+        
+        return new int[] {}; // No solution found
+    }
+}

Easy/2025-01-27-0001-TwoSum/solution.js

@@ -0,0 +1,25 @@
+// Solution for LeetCode Problem #1: Two Sum
+// Date: 2025-01-27
+// Difficulty: Easy
+// Language: JavaScript
+
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function(nums, target) {
+    const map = new Map();
+    
+    for (let i = 0; i < nums.length; i++) {
+        const complement = target - nums[i];
+        
+        if (map.has(complement)) {
+            return [map.get(complement), i];
+        }
+        
+        map.set(nums[i], i);
+    }
+    
+    return []; // No solution found
+};

Medium/2025-07-29-2044-CountNumberOfMaximumBitwiseORSubsets/explanation.md

@@ -0,0 +1,153 @@
+# Count Number of Maximum Bitwise OR Subsets - Problem #2044
+
+## Problem Statement
+You are given an integer array nums. We call a subset of nums good if its bitwise OR is a maximum value among all possible subsets of nums.
+
+Let size be the number of integers in a good subset.
+
+Return the number of different good subsets of size size.
+
+## Examples
+```
+Input: nums = [3,1]
+Output: 2
+Explanation: The maximum possible bitwise OR of a subset is 3. There are 2 subsets with a bitwise OR of 3:
+- [3]
+- [3,1]
+
+Input: nums = [2,2,2]
+Output: 7
+Explanation: All non-empty subsets of [2,2,2] have a bitwise OR of 2. There are 2^3 - 1 = 7 total subsets.
+
+Input: nums = [3,2,1,5]
+Output: 6
+Explanation: The maximum possible bitwise OR of a subset is 7, and the subsets with a bitwise OR of 7 are:
+- [3,5]
+- [3,1,5]
+- [3,2,5]
+- [3,2,1,5]
+- [1,5]
+- [2,1,5]
+```
+
+## Approach
+**Backtracking with Bitwise OR Tracking:**
+1. First, find the maximum possible bitwise OR value among all possible subsets
+2. Use backtracking to generate all possible subsets
+3. For each subset, calculate its bitwise OR value
+4. Count how many subsets achieve the maximum OR value
+5. Among those subsets, count how many have the maximum size
+
+**Algorithm Steps:**
+1. Calculate the maximum possible OR value by OR-ing all elements
+2. Use backtracking to generate all possible subsets
+3. For each subset, track its OR value and size
+4. Count subsets that achieve maximum OR and have maximum size among those
+
+## Complexity Analysis
+- **Time Complexity**: O(2^n) - We generate all possible subsets using backtracking
+- **Space Complexity**: O(n) - Recursion stack depth for backtracking
+
+## Key Insights
+- The maximum possible OR value is the OR of all elements in the array
+- We need to find all subsets that achieve this maximum OR value
+- Among those subsets, we count the ones with the maximum size
+- Backtracking is efficient for generating all possible subsets
+- We can optimize by tracking the maximum size among subsets that achieve the target OR
+
+## Alternative Approaches
+1. **Bit Manipulation**: Use bit masks to represent subsets - O(2^n)
+2. **Dynamic Programming**: Use DP to track OR values for different subset sizes
+3. **Greedy**: Optimize by stopping early when maximum OR is achieved
+
+## Solutions in Different Languages
+
+### Java
+```java
+class Solution {
+    private int maxOR = 0;
+    private int maxSize = 0;
+    private int count = 0;
+    
+    public int countMaxOrSubsets(int[] nums) {
+        // Calculate the maximum possible OR value
+        maxOR = 0;
+        for (int num : nums) {
+            maxOR |= num;
+        }
+        
+        // Reset counters
+        maxSize = 0;
+        count = 0;
+        
+        // Use backtracking to find all subsets
+        backtrack(nums, 0, 0, 0);
+        
+        return count;
+    }
+    
+    private void backtrack(int[] nums, int index, int currentOR, int currentSize) {
+        // If we've processed all elements
+        if (index == nums.length) {
+            // If this subset achieves the maximum OR
+            if (currentOR == maxOR) {
+                // If this is the first subset with max OR, or same size as current max
+                if (currentSize > maxSize) {
+                    maxSize = currentSize;
+                    count = 1;
+                } else if (currentSize == maxSize) {
+                    count++;
+                }
+            }
+            return;
+        }
+        
+        // Include the current element
+        backtrack(nums, index + 1, currentOR | nums[index], currentSize + 1);
+        
+        // Exclude the current element
+        backtrack(nums, index + 1, currentOR, currentSize);
+    }
+}
+```
+
+### JavaScript
+```javascript
+var countMaxOrSubsets = function(nums) {
+    // Calculate the maximum possible OR value
+    let maxOR = 0;
+    for (let num of nums) {
+        maxOR |= num;
+    }
+    
+    let maxSize = 0;
+    let count = 0;
+    
+    // Use backtracking to find all subsets
+    function backtrack(index, currentOR, currentSize) {
+        // If we've processed all elements
+        if (index === nums.length) {
+            // If this subset achieves the maximum OR
+            if (currentOR === maxOR) {
+                // If this is the first subset with max OR, or same size as current max
+                if (currentSize > maxSize) {
+                    maxSize = currentSize;
+                    count = 1;
+                } else if (currentSize === maxSize) {
+                    count++;
+                }
+            }
+            return;
+        }
+        
+        // Include the current element
+        backtrack(index + 1, currentOR | nums[index], currentSize + 1);
+        
+        // Exclude the current element
+        backtrack(index + 1, currentOR, currentSize);
+    }
+    
+    backtrack(0, 0, 0);
+    return count;
+};
+```