Merge pull request Dijkstra-Edu#52 from Vitessse/ransom

Solution - #383 - Andrew - 13/06/2025

Author: JRS296

Arrays & Strings/#383 - Ransom Note - Easy/Explaination.md

@@ -0,0 +1,132 @@
+# Problem Title
+
+**Difficulty:** Easy   
+**Category:** Strings,Hash table
+**Leetcode Link:** [Problem Link]https://leetcode.com/problems/ransom-note/
+
+---
+
+## 📝 Introduction
+
+You are given two strings: ransomNote and magazine.
+You need to determine if you can construct the ransomNote using the letters from magazine.
+
+Each letter in magazine can only be used once in ransomNote.
+Return true if possible, otherwise return false.
+
+Constraints:
+
+1 <= ransomNote.length, magazine.length <= 10⁵
+
+ransomNote and magazine consist of lowercase English letters
+
+---
+
+## 💡 Approach & Key Insights
+
+The key idea is to count the frequency of each character in both ransomNote and magazine.
+Then, ensure that for each character required by the ransom note, the magazine has at least that many occurrences.
+
+A brute force approach would be inefficient.
+Instead, we can use a hash map (or Python’s collections.Counter) to store and compare character frequencies efficiently.
+
+---
+
+## 🛠️ Breakdown of Approaches
+
+### 1️⃣ Brute Force / Naive Approach
+
+-**Explanation:** For every character in ransomNote, loop through magazine and find a match, removing used characters.
+This leads to nested iterations and repeated string operations.
+
+- **Time Complexity:** *O(n^2) -  nested loops for character comparisons*
+- **Space Complexity:** *O(1) - no additional data structures used*
+- **Example/Dry Run:**
+
+Example input: ransomNote = "aa", magazine = "aab"
+Step 1 → Check for 'a' in magazine → Found
+Step 2 → Remove 'a' → magazine = "ab"
+Step 3 → Check for 'a' again → Found
+Step 4 → Return true
+
+
+### 2️⃣ Optimized Approach
+
+- **Explanation:** Use a hash map to count how many times each letter appears in magazine.
+Then, for each letter in ransomNote, check if it exists in the map with sufficient count. Decrease the count as we go
+
+- **Time Complexity:** *O(m + n) - where m = len(magazine), n = len(ransomNote)*
+- **Space Complexity:** *O(1)-because character set is fixed (26 lowercase letters)
+
+- **Example/Dry Run:**
+
+ransomNote = "aa", magazine = "aab"
+Step 1 → magazine_counter = {'a': 2, 'b': 1}
+Step 2 → Check 'a' in ransomNote → Yes (2 available) → decrement to 1
+Step 3 → Check 'a' again → Yes (1 available) → decrement to 0
+Step 4 → Return true
+
+
+### 3️⃣ Best / Final Optimized Approach (if applicable)
+
+- **Explanation:** * Use a hash map to count how many times each letter appears in magazine.
+Then, for each letter in ransomNote, check if it exists in the map with sufficient count. Decrease the count as we go*
+- **Time Complexity:** *O(m + n) - where m = len(magazine), n = len(ransomNote)*
+- **Space Complexity:** *O(1) - because character set is fixed (26 lowercase letters)*
+- **Example/Dry Run:**
+
+Example input: 
+ransomNote = "aa", magazine = "aab"
+Step 1 → magazine_counter = {'a': 2, 'b': 1}
+Step 2 → Check 'a' in ransomNote → Yes (2 available) → decrement to 1
+Step 3 → Check 'a' again → Yes (1 available) → decrement to 0
+Step 4 → Return true
+---
+
+## 📊 Complexity Analysis
+
+| Approach      | Time Complexity | Space Complexity |
+| ------------- | --------------- | ---------------- |
+| Brute Force   | O(n^2)          | O(1)             |
+| Optimized     | O(m + n)        | O(1)             |
+| Best Approach | O(m + n)        | O(1)             |
+
+---
+
+## 📉 Optimization Ideas
+
+Use collections.Counter in Python for cleaner syntax and built-in methods for frequency counting and subtraction.
+
+Early exit: if len(ransomNote) > len(magazine), return False immediately.
+
+---
+
+## 📌 Example Walkthroughs & Dry Runs
+
+Example:
+Input: ransomNote = "abc", magazine = "aabbcc"
+Process:
+1 → Count magazine: {'a': 2, 'b': 2, 'c': 2}
+2 → 'a' needed → OK
+3 → 'b' needed → OK
+4 → 'c' needed → OK
+Output: true
+
+Input: ransomNote = "aab", magazine = "abc"
+Process:
+1 → Count magazine: {'a': 1, 'b': 1, 'c': 1}
+2 → 'a' needed → Only 1 'a' available
+Output: false
+
+---
+
+## 🔗 Additional Resources
+
+- collections.Counter docs
+- Pythonic Solution Discussion
+
+
+---
+
+Author: Andrew
+Date: 13/06/2025

Arrays & Strings/#383 - Ransom Note - Easy/Solution.py

@@ -0,0 +1,10 @@
+class Solution(object):
+    def canConstruct(self, ransomNote, magazine):
+        ransom_count = Counter(ransomNote)
+        magazine_count = Counter(magazine)
+
+        for letter, count in ransom_count.items():
+            if magazine_count[letter] < count:
+                return False
+    
+        return True

LeetCode-Solutions

@@ -0,0 +1 @@
+Subproject commit dd7a2d5de50b2544eb285506601392340c529811

Math/#2894 - DIvisible and non-divisible sums difference - Easy/Explaination.md

@@ -0,0 +1,133 @@
+# Problem Title
+
+**Difficulty:** Easy   
+**Category:** Math  
+**Leetcode Link:** [Problem Link](https://leetcode.com/problems/divisible-and-non-divisible-sums-difference/)
+
+---
+
+## 📝 Introduction
+
+You're given two integers, n and m. Your task is to calculate the difference between:
+
+num1: the sum of all numbers from 1 to n not divisible by m.
+
+num2: the sum of all numbers from 1 to n divisible by m.
+
+Return the value of num1 - num2.
+
+---
+
+## 💡 Approach & Key Insights
+
+The total sum of numbers from 1 to n is known via the formula: n(n + 1) / 2.
+
+The sum of numbers divisible by m is also a simple arithmetic series.
+
+Subtracting 2 * (sum of numbers divisible by m) from the total sum gives us num1 - num2.
+
+
+
+---
+
+## 🛠️ Breakdown of Approaches
+
+### 1️⃣ Brute Force / Naive Approach
+
+-**Explanation:** Loop through all numbers from 1 to n. For each number:
+
+If it is divisible by m, add to num2.
+
+Else, add to num1.
+Finally return num1 - num2.
+- **Time Complexity:** *O(?) - because we loop from 1 to n.*
+- **Space Complexity:** *O(?) - constant space for sums.*
+- **Example/Dry Run:**
+
+Example input: n = 10, m = 3
+
+Loop from 1 to 10:
+
+Not divisible by 3: 1 + 2 + 4 + 5 + 7 + 8 + 10 = 37
+
+Divisible by 3: 3 + 6 + 9 = 18
+
+Output: 37 - 18 = 19
+
+
+### 2️⃣ Optimized Approach
+
+- **Explanation:** Use math formulas to compute the total sum of numbers from 1 to n, and separately the sum of numbers divisible by m:
+
+Total sum: n(n + 1) / 2
+
+Sum divisible by m: m * k(k + 1) / 2 where k = n // m
+
+Return: total_sum - 2 * divisible_sum
+- **Time Complexity:** *O(1) - no loops, only arithmetic.*
+- **Space Complexity:** *O(1) 
+- **Example/Dry Run:**
+
+Input: n = 10, m = 3
+
+total_sum = 10 × 11 / 2 = 55
+
+k = 10 // 3 = 3
+
+divisible_sum = 3 × (3 × 4 / 2) = 3 × 6 = 18
+
+Output = 55 - 2 × 18 = 19
+
+
+### 3️⃣ Best / Final Optimized Approach (if applicable)
+
+- **Explanation:** *Discuss the best possible solution.*
+- **Time Complexity:** *O(?) - Explanation*
+- **Space Complexity:** *O(?) - Explanation*
+- **Example/Dry Run:**
+
+Example input: [Insert example] Step 1 → Step 2 → Step 3 → Output
+
+---
+
+## 📊 Complexity Analysis
+
+| Approach      | Time Complexity | Space Complexity |
+| ------------- | --------------- | ---------------- |
+| Brute Force   | O(n)            | O(1)             |
+| Optimized     | O(1)            | O(1)             |
+| Best Approach | O(?)            | O(?)             |
+
+---
+
+## 📉 Optimization Ideas
+
+The optimized solution already achieves constant time and space using mathematical formulas. No further optimization is necessary unless extending to very large ranges, in which case care for integer overflow may be required.
+
+---
+
+## 📌 Example Walkthroughs & Dry Runs
+
+Example:
+Input: n = 5, m = 2
+Total sum = 5 * 6 / 2 = 15
+Divisible by 2: 2 + 4 = 6
+Not divisible: 1 + 3 + 5 = 9
+Answer: 9 - 6 = 3
+
+Or:
+Answer = 15 - 2 * 6 = 3
+```
+
+---
+
+## 🔗 Additional Resources
+
+- Arithmetic Series - Wikipedia
+- Python Integer Arithmetic
+
+
+---
+
+Author: Andrew
+Date: 07/06/2025

Math/#2894 - DIvisible and non-divisible sums difference - Easy/Solution.py

@@ -0,0 +1,14 @@
+class Solution(object):
+    def differenceOfSums(self, n, m):
+        
+        totalsum = n * (n+1) // 2
+
+        
+        k = n // m
+
+        
+        sum_divisible_by_m = m * k * (k + 1) // 2
+
+        # num1 - num2 = (sum of numbers not divisible by m) - (sum of numbers divisible by m)
+        result = totalsum - 2 * sum_divisible_by_m
+        return result