From d58fb07a9efd9887ee5fe24f98e5078041616e23 Mon Sep 17 00:00:00 2001
From: Sri Hari <kataresrihari@gmail.com>
Date: Thu, 17 Apr 2025 21:22:14 +0530
Subject: [PATCH 1/2] Batch-6/Neetcode-ALL/Added-articles

---
 .../analyze-user-website-visit-pattern.md     | 224 ++++++++
 .../binary-tree-vertical-order-traversal.md   |  22 +-
 articles/maximum-profit-in-job-scheduling.md  | 155 ++++++
 articles/put-marbles-in-bags.md               | 501 ++++++++++++++++++
 articles/reorganize-string.md                 | 117 ++++
 5 files changed, 1008 insertions(+), 11 deletions(-)
 create mode 100644 articles/analyze-user-website-visit-pattern.md
 create mode 100644 articles/put-marbles-in-bags.md

diff --git a/articles/analyze-user-website-visit-pattern.md b/articles/analyze-user-website-visit-pattern.md
new file mode 100644
index 000000000..40aff68a5
--- /dev/null
+++ b/articles/analyze-user-website-visit-pattern.md
@@ -0,0 +1,224 @@
+## 1. Hash Map
+
+::tabs-start
+
+```python
+class Solution:
+    def mostVisitedPattern(self, username: List[str], timestamp: List[int], website: List[str]) -> List[str]:
+        arr = list(zip(timestamp, username, website))
+        arr.sort()
+
+        mp = defaultdict(list)
+        for time, user, site in arr:
+            mp[user].append(site)
+
+        count = defaultdict(int)
+        for user in mp:
+            patterns = set()
+            cur = mp[user]
+            for i in range(len(cur)):
+                for j in range(i + 1, len(cur)):
+                    for k in range(j + 1, len(cur)):
+                        patterns.add((cur[i], cur[j], cur[k]))
+            for p in patterns:
+                count[p] += 1
+
+        max_count = 0
+        res = tuple()
+        for pattern in count:
+            if count[pattern] > max_count or (count[pattern] == max_count and pattern < res):
+                max_count = count[pattern]
+                res = pattern
+
+        return list(res)
+```
+
+```java
+public class Solution {
+    public List<String> mostVisitedPattern(String[] username, int[] timestamp, String[] website) {
+        int n = timestamp.length;
+        List<int[]> arr = new ArrayList<>();
+        for (int i = 0; i < n; i++) arr.add(new int[]{timestamp[i], i});
+        arr.sort((a, b) -> Integer.compare(a[0], b[0]));
+
+        Map<String, List<String>> mp = new HashMap<>();
+        for (int[] p : arr) {
+            int idx = p[1];
+            mp.computeIfAbsent(username[idx], k -> new ArrayList<>()).add(website[idx]);
+        }
+
+        Map<String, Integer> count = new HashMap<>();
+        for (String user : mp.keySet()) {
+            List<String> cur = mp.get(user);
+            Set<String> patterns = new HashSet<>();
+            for (int i = 0; i < cur.size(); i++)
+                for (int j = i + 1; j < cur.size(); j++)
+                    for (int k = j + 1; k < cur.size(); k++)
+                        patterns.add(cur.get(i) + "#" + cur.get(j) + "#" + cur.get(k));
+            for (String p : patterns)
+                count.put(p, count.getOrDefault(p, 0) + 1);
+        }
+
+        String res = "";
+        int max_count = 0;
+        for (String p : count.keySet()) {
+            int c = count.get(p);
+            if (c > max_count || (c == max_count && p.compareTo(res) < 0)) {
+                max_count = c;
+                res = p;
+            }
+        }
+        return Arrays.asList(res.split("#"));
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<string> mostVisitedPattern(vector<string>& username, vector<int>& timestamp, vector<string>& website) {
+        int n = timestamp.size();
+        vector<pair<int,int>> arr;
+        for (int i = 0; i < n; ++i) arr.push_back({timestamp[i], i});
+        sort(arr.begin(), arr.end(),
+             [](auto& a, auto& b){ return a.first < b.first; });
+
+        unordered_map<string, vector<string>> mp;
+        for (auto& p : arr) mp[username[p.second]].push_back(website[p.second]);
+
+        unordered_map<string,int> count;
+        for (auto& kv : mp) {
+            auto& cur = kv.second;
+            unordered_set<string> patterns;
+            for (int i = 0; i < (int)cur.size(); ++i)
+                for (int j = i + 1; j < (int)cur.size(); ++j)
+                    for (int k = j + 1; k < (int)cur.size(); ++k)
+                        patterns.insert(cur[i] + "#" + cur[j] + "#" + cur[k]);
+            for (auto& p : patterns) ++count[p];
+        }
+
+        int maxCnt = 0;
+        string res;
+        for (auto& kv : count)
+            if (kv.second > maxCnt ||
+               (kv.second == maxCnt && (res.empty() || kv.first < res))) {
+                maxCnt = kv.second;
+                res = kv.first;
+            }
+
+        vector<string> ans;
+        string tmp;
+        for (char ch : res) {
+            if (ch == '#') { 
+                ans.push_back(tmp);
+                tmp.clear();
+            } else {
+                tmp += ch;
+            }
+        }
+        ans.push_back(tmp);
+        return ans;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string[]} username
+     * @param {number[]} timestamp
+     * @param {string[]} website
+     * @return {string[]}
+     */
+    mostVisitedPattern(username, timestamp, website) {
+        const n = timestamp.length;
+        const arr = [];
+        for (let i = 0; i < n; i++) arr.push([timestamp[i], i]);
+        arr.sort((a, b) => a[0] - b[0]);
+
+        const mp = new Map();
+        for (const [, idx] of arr) {
+            const user = username[idx], site = website[idx];
+            if (!mp.has(user)) mp.set(user, []);
+            mp.get(user).push(site);
+        }
+
+        const count = new Map();
+        for (const user of mp.keys()) {
+            const cur = mp.get(user);
+            const patterns = new Set();
+            for (let i = 0; i < cur.length; i++) {
+                for (let j = i + 1; j < cur.length; j++) {
+                    for (let k = j + 1; k < cur.length; k++) {
+                        patterns.add(`${cur[i]}#${cur[j]}#${cur[k]}`);
+                    }
+                }
+            }
+            for (const p of patterns) {
+                count.set(p, (count.get(p) || 0) + 1);
+            }
+        }
+
+        let maxCnt = 0, res = "";
+        for (const [pat, c] of count.entries()) {
+            if (c > maxCnt || (c === maxCnt && (res === "" || pat < res))) {
+                maxCnt = c;
+                res = pat;
+            }
+        }
+        return res.split("#");
+    }
+}
+```
+
+```csharp
+public class Solution {
+    public IList<string> MostVisitedPattern(string[] username, int[] timestamp, string[] website) {
+        int n = timestamp.Length;
+        var arr = new List<(int t, int i)>();
+        for (int i = 0; i < n; i++) arr.Add((timestamp[i], i));
+        arr.Sort((a, b) => a.t.CompareTo(b.t));
+
+        var mp = new Dictionary<string, List<string>>();
+        foreach (var (t, idx) in arr) {
+            string user = username[idx], site = website[idx];
+            if (!mp.ContainsKey(user)) mp[user] = new List<string>();
+            mp[user].Add(site);
+        }
+
+        var count = new Dictionary<string,int>();
+        foreach (var kv in mp) {
+            var cur = kv.Value;
+            var patterns = new HashSet<string>();
+            for (int i = 0; i < cur.Count; i++)
+                for (int j = i + 1; j < cur.Count; j++)
+                    for (int k = j + 1; k < cur.Count; k++)
+                        patterns.Add($"{cur[i]}#{cur[j]}#{cur[k]}");
+            foreach (var p in patterns) {
+                count[p] = count.ContainsKey(p) ? count[p] + 1 : 1;
+            }
+        }
+
+        int maxCnt = 0;
+        string res = "";
+        foreach (var kv in count) {
+            if (kv.Value > maxCnt ||
+                (kv.Value == maxCnt &&
+                (res == "" || string.Compare(kv.Key, res, StringComparison.Ordinal) < 0))) {
+                maxCnt = kv.Value;
+                res = kv.Key;
+            }
+        }
+        return res.Split('#');
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n \log n + n * u +  n ^ 3 * w)$
+* Space complexity: $O(n * u + n ^ 3 * w)$
+
+> Where $n$ is the size of the array $timestamp$, $u$ is the maximum length of any string in the array $username$, and $w$ is the maximum length of any string in the array $website$.
\ No newline at end of file
diff --git a/articles/binary-tree-vertical-order-traversal.md b/articles/binary-tree-vertical-order-traversal.md
index 506fdad2c..c66e08d0b 100644
--- a/articles/binary-tree-vertical-order-traversal.md
+++ b/articles/binary-tree-vertical-order-traversal.md
@@ -151,8 +151,8 @@ class Solution {
  * }
  */
 public class Solution {
-    public IList<IList<int>> VerticalOrder(TreeNode root) {
-        if (root == null) return new List<IList<int>>();
+    public List<List<int>> VerticalOrder(TreeNode root) {
+        if (root == null) return new List<List<int>>();
 
         var cols = new SortedDictionary<int, List<int>>();
         var queue = new Queue<(TreeNode node, int pos)>();
@@ -169,7 +169,7 @@ public class Solution {
             if (node.right != null) queue.Enqueue((node.right, pos + 1));
         }
 
-        return cols.Values.ToList<IList<int>>();
+        return cols.Values.ToList<List<int>>();
     }
 }
 ```
@@ -354,10 +354,10 @@ class Solution {
 public class Solution {
     private SortedDictionary<int, List<(int, int)>> cols = new();
 
-    public IList<IList<int>> VerticalOrder(TreeNode root) {
+    public List<List<int>> VerticalOrder(TreeNode root) {
         DFS(root, 0, 0);
 
-        List<IList<int>> res = new();
+        List<List<int>> res = new();
         foreach (var entry in cols) {
             var list = entry.Value.OrderBy(x => x.Item1).Select(x => x.Item2).ToList();
             res.Add(list);
@@ -565,8 +565,8 @@ class Solution {
  * }
  */
 public class Solution {
-    public IList<IList<int>> VerticalOrder(TreeNode root) {
-        if (root == null) return new List<IList<int>>();
+    public List<List<int>> VerticalOrder(TreeNode root) {
+        if (root == null) return new List<List<int>>();
 
         Dictionary<int, List<int>> cols = new();
         Queue<(TreeNode node, int col)> queue = new();
@@ -585,7 +585,7 @@ public class Solution {
             if (node.right != null) queue.Enqueue((node.right, col + 1));
         }
 
-        var res = new List<IList<int>>();
+        var res = new List<List<int>>();
         for (int c = minCol; c <= maxCol; c++) {
             res.Add(cols[c]);
         }
@@ -801,10 +801,10 @@ public class Solution {
     private Dictionary<int, List<(int, int)>> cols = new();
     private int minCol = 0, maxCol = 0;
 
-    public IList<IList<int>> VerticalOrder(TreeNode root) {
-        if (root == null) return new List<IList<int>>();
+    public List<List<int>> VerticalOrder(TreeNode root) {
+        if (root == null) return new List<List<int>>();
         DFS(root, 0, 0);
-        var res = new List<IList<int>>();
+        var res = new List<List<int>>();
 
         for (int c = minCol; c <= maxCol; c++) {
             var list = cols.ContainsKey(c) ? cols[c] : new List<(int, int)>();
diff --git a/articles/maximum-profit-in-job-scheduling.md b/articles/maximum-profit-in-job-scheduling.md
index 181614b62..0c0d40541 100644
--- a/articles/maximum-profit-in-job-scheduling.md
+++ b/articles/maximum-profit-in-job-scheduling.md
@@ -155,6 +155,42 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int JobScheduling(int[] startTime, int[] endTime, int[] profit) {
+        int n = startTime.Length;
+        var intervals = new List<(int start, int end, int profit)>();
+
+        for (int i = 0; i < n; i++) {
+            intervals.Add((startTime[i], endTime[i], profit[i]));
+        }
+
+        intervals.Sort((a, b) => a.start.CompareTo(b.start));
+        Dictionary<int, int> cache = new();
+
+        int Dfs(int i) {
+            if (i == n) return 0;
+            if (cache.ContainsKey(i)) return cache[i];
+
+            // Option 1: don't include
+            int res = Dfs(i + 1);
+
+            // Option 2: include current job
+            int j = i + 1;
+            while (j < n && intervals[j].start < intervals[i].end) {
+                j++;
+            }
+
+            res = Math.Max(res, intervals[i].profit + Dfs(j));
+            cache[i] = res;
+            return res;
+        }
+
+        return Dfs(0);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -328,6 +364,48 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private int[][] intervals;
+    private int[] cache;
+
+    public int JobScheduling(int[] startTime, int[] endTime, int[] profit) {
+        int n = startTime.Length;
+        intervals = new int[n][];
+        cache = new int[n];
+        Array.Fill(cache, -1);
+
+        for (int i = 0; i < n; i++) {
+            intervals[i] = new int[] { startTime[i], endTime[i], profit[i] };
+        }
+
+        Array.Sort(intervals, (a, b) => a[0].CompareTo(b[0]));
+        return Dfs(0);
+    }
+
+    private int Dfs(int i) {
+        if (i == intervals.Length) return 0;
+        if (cache[i] != -1) return cache[i];
+
+        int res = Dfs(i + 1);
+
+        int left = i + 1, right = intervals.Length, j = intervals.Length;
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            if (intervals[mid][0] >= intervals[i][1]) {
+                j = mid;
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+
+        cache[i] = Math.Max(res, intervals[i][2] + Dfs(j));
+        return cache[i];
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -517,6 +595,52 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private int[] startTime, endTime, profit, cache;
+    private int[] index;
+    private int n;
+
+    public int JobScheduling(int[] startTime, int[] endTime, int[] profit) {
+        this.n = startTime.Length;
+        this.startTime = startTime;
+        this.endTime = endTime;
+        this.profit = profit;
+        this.index = new int[n];
+        this.cache = new int[n];
+        Array.Fill(cache, -1);
+
+        for (int i = 0; i < n; i++) {
+            index[i] = i;
+        }
+
+        Array.Sort(index, (a, b) => startTime[a].CompareTo(startTime[b]));
+
+        return Dfs(0);
+    }
+
+    private int Dfs(int i) {
+        if (i == n) return 0;
+        if (cache[i] != -1) return cache[i];
+
+        int res = Dfs(i + 1);
+
+        int left = i + 1, right = n, j = n;
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            if (startTime[index[mid]] >= endTime[index[i]]) {
+                j = mid;
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+
+        return cache[i] = Math.Max(res, profit[index[i]] + Dfs(j));
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -647,6 +771,37 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int JobScheduling(int[] startTime, int[] endTime, int[] profit) {
+        int n = startTime.Length;
+        int[] index = new int[n];
+        for (int i = 0; i < n; i++) index[i] = i;
+
+        Array.Sort(index, (a, b) => startTime[a].CompareTo(startTime[b]));
+
+        int[] dp = new int[n + 1];
+
+        for (int i = n - 1; i >= 0; i--) {
+            int left = i + 1, right = n, j = n;
+            while (left < right) {
+                int mid = left + (right - left) / 2;
+                if (startTime[index[mid]] >= endTime[index[i]]) {
+                    j = mid;
+                    right = mid;
+                } else {
+                    left = mid + 1;
+                }
+            }
+
+            dp[i] = Math.Max(dp[i + 1], profit[index[i]] + dp[j]);
+        }
+
+        return dp[0];
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/put-marbles-in-bags.md b/articles/put-marbles-in-bags.md
new file mode 100644
index 000000000..a0abf8a29
--- /dev/null
+++ b/articles/put-marbles-in-bags.md
@@ -0,0 +1,501 @@
+## 1. Dynamic Programming (Top-Down)
+
+::tabs-start
+
+```python
+class Solution:
+    def putMarbles(self, weights: List[int], k: int) -> int:
+        n = len(weights)
+        cache = {}
+
+        def dfs(i, k):
+            if (i, k) in cache:
+                return cache[(i, k)]
+            if k == 0:
+                return [0, 0]
+            if i == n - 1 or n - i - 1 < k:
+                return [-float("inf"), float("inf")]
+
+            res = [0, float("inf")]  # [maxScore, minScore]
+
+            # make partition
+            cur = dfs(i + 1, k - 1)
+            res[0] = max(res[0], weights[i] + weights[i + 1] + cur[0])
+            res[1] = min(res[1], weights[i] + weights[i + 1] + cur[1])
+
+            # skip
+            cur = dfs(i + 1, k)
+            res[0] = max(res[0], cur[0])
+            res[1] = min(res[1], cur[1])
+
+            cache[(i, k)] = res
+            return res
+
+        ans = dfs(0, k - 1)
+        return ans[0] - ans[1]
+```
+
+```java
+public class Solution {
+    Map<String, long[]> cache = new HashMap<>();
+
+    public long putMarbles(int[] weights, int k) {
+        int n = weights.length;
+        long[] ans = dfs(0, k - 1, weights, n);
+        return ans[0] - ans[1];
+    }
+
+    private long[] dfs(int i, int k, int[] weights, int n) {
+        String key = i + "," + k;
+        if (cache.containsKey(key)) return cache.get(key);
+        if (k == 0) return new long[]{0L, 0L};
+        if (i == n - 1 || n - i - 1 < k) {
+            return new long[]{(long)-1e15, (long)1e15};
+        }
+
+        long[] res = new long[]{0L, (long)1e15};
+
+        long[] cur = dfs(i + 1, k - 1, weights, n);
+        res[0] = Math.max(res[0], weights[i] + weights[i + 1] + cur[0]);
+        res[1] = Math.min(res[1], weights[i] + weights[i + 1] + cur[1]);
+
+        cur = dfs(i + 1, k, weights, n);
+        res[0] = Math.max(res[0], cur[0]);
+        res[1] = Math.min(res[1], cur[1]);
+
+        cache.put(key, res);
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    unordered_map<string, pair<long long, long long>> cache;
+
+    long long putMarbles(vector<int>& weights, int k) {
+        int n = weights.size();
+        auto ans = dfs(0, k - 1, weights, n);
+        return ans.first - ans.second;
+    }
+
+    pair<long long, long long> dfs(int i, int k, vector<int>& weights, int n) {
+        string key = to_string(i) + "," + to_string(k);
+        if (cache.count(key)) return cache[key];
+        if (k == 0) return {0LL, 0LL};
+        if (i == n - 1 || n - i - 1 < k) {
+            return {-1000000000000000LL, 1000000000000000LL};
+        }
+
+        pair<long long, long long> res = {0LL, 1000000000000000LL};
+
+        auto cur = dfs(i + 1, k - 1, weights, n);
+        res.first = max(res.first, (long long)weights[i] + weights[i + 1] + cur.first);
+        res.second = min(res.second, (long long)weights[i] + weights[i + 1] + cur.second);
+
+        cur = dfs(i + 1, k, weights, n);
+        res.first = max(res.first, cur.first);
+        res.second = min(res.second, cur.second);
+
+        return cache[key] = res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} weights
+     * @param {number} k
+     * @return {number}
+     */
+    putMarbles(weights, k) {
+        const n = weights.length;
+        const cache = new Map();
+
+        const dfs = (i, k) => {
+            const key = `${i},${k}`;
+            if (cache.has(key)) return cache.get(key);
+            if (k === 0) return [0, 0];
+            if (i === n - 1 || n - i - 1 < k) return [-1e15, 1e15];
+
+            let res = [0, 1e15];
+
+            let cur = dfs(i + 1, k - 1);
+            res[0] = Math.max(res[0], weights[i] + weights[i + 1] + cur[0]);
+            res[1] = Math.min(res[1], weights[i] + weights[i + 1] + cur[1]);
+
+            cur = dfs(i + 1, k);
+            res[0] = Math.max(res[0], cur[0]);
+            res[1] = Math.min(res[1], cur[1]);
+
+            cache.set(key, res);
+            return res;
+        };
+
+        const ans = dfs(0, k - 1);
+        return ans[0] - ans[1];
+    }
+}
+```
+
+```csharp
+public class Solution {
+    Dictionary<string, long[]> cache = new Dictionary<string, long[]>();
+
+    public long PutMarbles(int[] weights, int k) {
+        int n = weights.Length;
+        long[] ans = Dfs(0, k - 1, weights, n);
+        return (int)(ans[0] - ans[1]);
+    }
+
+    private long[] Dfs(int i, int k, int[] weights, int n) {
+        string key = $"{i},{k}";
+        if (cache.ContainsKey(key)) return cache[key];
+        if (k == 0) return new long[] { 0L, 0L };
+        if (i == n - 1 || n - i - 1 < k) {
+            return new long[] { -1000000000000000L, 1000000000000000L };
+        }
+
+        long[] res = new long[] { 0L, 1000000000000000L };
+
+        long[] cur = Dfs(i + 1, k - 1, weights, n);
+        res[0] = Math.Max(res[0], weights[i] + weights[i + 1] + cur[0]);
+        res[1] = Math.Min(res[1], weights[i] + weights[i + 1] + cur[1]);
+
+        cur = Dfs(i + 1, k, weights, n);
+        res[0] = Math.Max(res[0], cur[0]);
+        res[1] = Math.Min(res[1], cur[1]);
+
+        cache[key] = res;
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n * k)$
+* Space complexity: $O(n * k)$
+
+> Where $n$ is the number of marbles, and $k$ is the number of bags.
+
+---
+
+## 2. Greedy + Sorting
+
+::tabs-start
+
+```python
+class Solution:
+    def putMarbles(self, weights: List[int], k: int) -> int:
+        if k == 1:
+            return 0
+
+        splits = []
+        for i in range(len(weights) - 1):
+            splits.append(weights[i] + weights[i + 1])
+
+        splits.sort()
+        i = k - 1
+
+        max_score = sum(splits[-i:])
+        min_score = sum(splits[:i])
+        return max_score - min_score
+```
+
+```java
+public class Solution {
+    public long putMarbles(int[] weights, int k) {
+        if (k == 1) return 0L;
+
+        int n = weights.length;
+        List<Integer> splits = new ArrayList<>();
+
+        for (int i = 0; i < n - 1; i++) {
+            splits.add(weights[i] + weights[i + 1]);
+        }
+
+        Collections.sort(splits);
+        int i = k - 1;
+        long maxScore = 0, minScore = 0;
+
+        for (int j = 0; j < i; j++) minScore += splits.get(j);
+        for (int j = splits.size() - i; j < splits.size(); j++) {
+            maxScore += splits.get(j);
+        }
+
+        return maxScore - minScore;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    long long putMarbles(vector<int>& weights, int k) {
+        if (k == 1) return 0LL;
+
+        int n = weights.size();
+        vector<int> splits;
+
+        for (int i = 0; i < n - 1; ++i) {
+            splits.push_back(weights[i] + weights[i + 1]);
+        }
+
+        sort(splits.begin(), splits.end());
+        int i = k - 1;
+        long long minScore = 0, maxScore = 0;
+
+        for (int j = 0; j < i; ++j) minScore += splits[j];
+        for (int j = splits.size() - i; j < splits.size(); ++j) {
+            maxScore += splits[j];
+        }   
+
+        return maxScore - minScore;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} weights
+     * @param {number} k
+     * @return {number}
+     */
+    putMarbles(weights, k) {
+        if (k === 1) return 0;
+
+        const splits = [];
+        for (let i = 0; i < weights.length - 1; i++) {
+            splits.push(weights[i] + weights[i + 1]);
+        }
+
+        splits.sort((a, b) => a - b);
+        const i = k - 1;
+
+        let minScore = 0, maxScore = 0;
+        for (let j = 0; j < i; j++) minScore += splits[j];
+        for (let j = splits.length - i; j < splits.length; j++) {
+            maxScore += splits[j];
+        }
+
+        return maxScore - minScore;
+    }
+}
+```
+
+```csharp
+public class Solution {
+    public long PutMarbles(int[] weights, int k) {
+        if (k == 1) return 0L;
+
+        int n = weights.Length;
+        List<int> splits = new List<int>();
+
+        for (int i = 0; i < n - 1; i++) {
+            splits.Add(weights[i] + weights[i + 1]);
+        }
+
+        splits.Sort();
+        int iVal = k - 1;
+        long minScore = 0, maxScore = 0;
+
+        for (int j = 0; j < iVal; j++) minScore += splits[j];
+        for (int j = splits.Count - iVal; j < splits.Count; j++) {
+            maxScore += splits[j];
+        }
+
+        return maxScore - minScore;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n \log n)$
+* Space complexity: $O(n)$
+
+> Where $n$ is the number of marbles, and $k$ is the number of bags.
+
+---
+
+## 3. Heap
+
+::tabs-start
+
+```python
+class Solution:
+    def putMarbles(self, weights: List[int], k: int) -> int:
+        if k == 1:
+            return 0
+
+        max_heap = []
+        min_heap = []
+
+        for i in range(len(weights) - 1):
+            split = weights[i] + weights[i + 1]
+
+            if len(max_heap) < k - 1:
+                heapq.heappush(max_heap, split)
+            else:
+                heapq.heappushpop(max_heap, split)
+
+            if len(min_heap) < k - 1:
+                heapq.heappush(min_heap, -split)
+            else:
+                heapq.heappushpop(min_heap, -split)
+
+        max_score = sum(max_heap)
+        min_score = -sum(min_heap)
+        return max_score - min_score
+```
+
+```java
+public class Solution {
+    public long putMarbles(int[] weights, int k) {
+        if (k == 1) return 0L;
+
+        PriorityQueue<Integer> maxHeap = new PriorityQueue<>();
+        PriorityQueue<Integer> minHeap = new PriorityQueue<>(Collections.reverseOrder());
+
+        for (int i = 0; i < weights.length - 1; i++) {
+            int split = weights[i] + weights[i + 1];
+
+            if (maxHeap.size() < k - 1) maxHeap.offer(split);
+            else if (split > maxHeap.peek()) {
+                maxHeap.poll();
+                maxHeap.offer(split);
+            }
+
+            if (minHeap.size() < k - 1) minHeap.offer(split);
+            else if (split < minHeap.peek()) {
+                minHeap.poll();
+                minHeap.offer(split);
+            }
+        }
+
+        long maxScore = 0, minScore = 0;
+        for (int val : maxHeap) maxScore += val;
+        for (int val : minHeap) minScore += val;
+
+        return maxScore - minScore;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    long long putMarbles(vector<int>& weights, int k) {
+        if (k == 1) return 0LL;
+
+        priority_queue<int, vector<int>, greater<int>> maxHeap;
+        priority_queue<int> minHeap;
+
+        for (int i = 0; i < weights.size() - 1; ++i) {
+            int split = weights[i] + weights[i + 1];
+
+            if ((int)maxHeap.size() < k - 1) maxHeap.push(split);
+            else if (split > maxHeap.top()) {
+                maxHeap.pop();
+                maxHeap.push(split);
+            }
+
+            if ((int)minHeap.size() < k - 1) minHeap.push(split);
+            else if (split < minHeap.top()) {
+                minHeap.pop();
+                minHeap.push(split);
+            }
+        }
+
+        long long maxScore = 0, minScore = 0;
+        while (!maxHeap.empty()) {
+            maxScore += maxHeap.top();
+            maxHeap.pop();
+        }
+        while (!minHeap.empty()) {
+            minScore += minHeap.top();
+            minHeap.pop();
+        }
+
+        return maxScore - minScore;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} weights
+     * @param {number} k
+     * @return {number}
+     */
+    putMarbles(weights, k) {
+        if (k === 1) return 0;
+
+        const minHeap = new MinPriorityQueue();
+        const maxHeap = new MaxPriorityQueue();
+
+        for (let i = 0; i < weights.length - 1; i++) {
+            const sum = weights[i] + weights[i + 1];
+
+            minHeap.enqueue(sum);
+            if (minHeap.size() > k - 1) minHeap.dequeue();
+
+            maxHeap.enqueue(sum);
+            if (maxHeap.size() > k - 1) maxHeap.dequeue();
+        }
+
+        let maxScore = 0, minScore = 0;
+        while (!minHeap.isEmpty()) maxScore += minHeap.dequeue();
+        while (!maxHeap.isEmpty()) minScore += maxHeap.dequeue();
+
+        return maxScore - minScore;
+    }
+}
+```
+
+```csharp
+public class Solution {
+    public long PutMarbles(int[] weights, int k) {
+        if (k == 1) return 0L;
+
+        var maxHeap = new PriorityQueue<int, int>();
+        var minHeap = new PriorityQueue<int, int>(
+            Comparer<int>.Create((a, b) => b.CompareTo(a))
+        );
+
+        for (int i = 0; i < weights.Length - 1; i++) {
+            int split = weights[i] + weights[i + 1];
+
+            maxHeap.Enqueue(split, split);
+            if (maxHeap.Count > k - 1) maxHeap.Dequeue();
+
+            minHeap.Enqueue(split, split);
+            if (minHeap.Count > k - 1) minHeap.Dequeue();
+        }
+
+        long maxScore = 0, minScore = 0;
+        while (maxHeap.Count > 0) maxScore += maxHeap.Dequeue();
+        while (minHeap.Count > 0) minScore += minHeap.Dequeue();
+
+        return maxScore - minScore;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n \log k)$
+* Space complexity: $O(k)$
+
+> Where $n$ is the number of marbles, and $k$ is the number of bags.
\ No newline at end of file
diff --git a/articles/reorganize-string.md b/articles/reorganize-string.md
index 57d672327..868c78dca 100644
--- a/articles/reorganize-string.md
+++ b/articles/reorganize-string.md
@@ -183,6 +183,42 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public string ReorganizeString(string s) {
+        int[] freq = new int[26];
+        foreach (char c in s) {
+            freq[c - 'a']++;
+        }
+
+        int maxFreq = freq.Max();
+        if (maxFreq > (s.Length + 1) / 2) {
+            return "";
+        }
+
+        List<char> res = new List<char>();
+        while (res.Count < s.Length) {
+            int maxIdx = Array.IndexOf(freq, freq.Max());
+            char ch = (char)(maxIdx + 'a');
+            res.Add(ch);
+            freq[maxIdx]--;
+
+            if (freq[maxIdx] == 0) continue;
+
+            int tmp = freq[maxIdx];
+            freq[maxIdx] = int.MinValue;
+            int nextMaxIdx = Array.IndexOf(freq, freq.Max());
+            char nextCh = (char)(nextMaxIdx + 'a');
+            res.Add(nextCh);
+            freq[maxIdx] = tmp;
+            freq[nextMaxIdx]--;
+        }
+
+        return new string(res.ToArray());
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -352,6 +388,45 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public string ReorganizeString(string s) {
+        Dictionary<char, int> count = new();
+        foreach (char c in s) {
+            if (!count.ContainsKey(c)) count[c] = 0;
+            count[c]++;
+        }
+
+        PriorityQueue<int[], int> maxHeap = new();
+        foreach (var kvp in count) {
+            maxHeap.Enqueue(new int[] { kvp.Value, kvp.Key }, -kvp.Value);
+        }
+
+        string res = "";
+        int[] prev = null;
+
+        while (maxHeap.Count > 0 || prev != null) {
+            if (prev != null && maxHeap.Count == 0) return "";
+
+            int[] curr = maxHeap.Dequeue();
+            res += (char)curr[1];
+            curr[0]--;
+
+            if (prev != null) {
+                maxHeap.Enqueue(prev, -prev[0]);
+                prev = null;
+            }
+
+            if (curr[0] > 0) {
+                prev = curr;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -536,6 +611,48 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public string ReorganizeString(string s) {
+        int[] freq = new int[26];
+        foreach (char c in s) {
+            freq[c - 'a']++;
+        }
+
+        int maxIdx = 0;
+        for (int i = 1; i < 26; i++) {
+            if (freq[i] > freq[maxIdx]) {
+                maxIdx = i;
+            }
+        }
+
+        int maxFreq = freq[maxIdx];
+        if (maxFreq > (s.Length + 1) / 2) return "";
+
+        char[] res = new char[s.Length];
+        int idx = 0;
+        char maxChar = (char)(maxIdx + 'a');
+
+        while (freq[maxIdx] > 0) {
+            res[idx] = maxChar;
+            idx += 2;
+            freq[maxIdx]--;
+        }
+
+        for (int i = 0; i < 26; i++) {
+            while (freq[i] > 0) {
+                if (idx >= s.Length) idx = 1;
+                res[idx] = (char)(i + 'a');
+                idx += 2;
+                freq[i]--;
+            }
+        }
+
+        return new string(res);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity

From 4c469ab069a490070d8c31f5913cd909cca86bdb Mon Sep 17 00:00:00 2001
From: Sri Hari <kataresrihari@gmail.com>
Date: Sat, 19 Apr 2025 21:07:01 +0530
Subject: [PATCH 2/2] Batch-6/Neetcode-ALL/Added-articles

---
 articles/analyze-user-website-visit-pattern.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/articles/analyze-user-website-visit-pattern.md b/articles/analyze-user-website-visit-pattern.md
index 40aff68a5..c43fce6ba 100644
--- a/articles/analyze-user-website-visit-pattern.md
+++ b/articles/analyze-user-website-visit-pattern.md
@@ -173,7 +173,7 @@ class Solution {
 
 ```csharp
 public class Solution {
-    public IList<string> MostVisitedPattern(string[] username, int[] timestamp, string[] website) {
+    public List<string> MostVisitedPattern(string[] username, int[] timestamp, string[] website) {
         int n = timestamp.Length;
         var arr = new List<(int t, int i)>();
         for (int i = 0; i < n; i++) arr.Add((timestamp[i], i));
@@ -209,7 +209,7 @@ public class Solution {
                 res = kv.Key;
             }
         }
-        return res.Split('#');
+        return new List<string>(res.Split('#'));
     }
 }
 ```