updated

Author: Prakash-sa

README.md

@@ -6,7 +6,7 @@ This repo includes a static site under `docs/` with a collapsible folder navigat
 
 - Set your repo owner and name in `docs/config.json` (or rely on auto-detection if using `https://<owner>.github.io/<repo>/`).
 - In GitHub Pages settings, choose `GitHub Actions` as the source.
-- If the tree changes, regenerate `docs/tree.json` with `python3 docs/build_tree.py`.
+- If the tree changes, regenerate `docs/tree.json` (and `docs/content/`) with `python3 docs/build_tree.py`.
 
 ## Time Complexity
 

docs/app.js

@@ -5,6 +5,7 @@ const state = {
   branch: "main",
   currentPath: "README.md",
   activeItem: null,
+  useLocalContent: false,
 };
 
 const treeRoot = document.getElementById("treeRoot");
@@ -38,8 +39,11 @@ function encodePath(path) {
     .join("/");
 }
 
-function rawUrlForPath(path) {
+function fileUrlForPath(path) {
   const encoded = encodePath(path);
+  if (state.useLocalContent) {
+    return `content/${encoded}`;
+  }
   return `https://raw.githubusercontent.com/${state.repoOwner}/${state.repoName}/${state.branch}/${encoded}`;
 }
 
@@ -107,7 +111,7 @@ async function loadFile(path, meta = {}) {
   codeBlock.className = languageClass ? `language-${languageClass}` : "";
 
   try {
-    const response = await fetch(rawUrlForPath(path));
+    const response = await fetch(fileUrlForPath(path));
     if (!response.ok) {
       throw new Error(`Failed to fetch ${path}`);
     }
@@ -275,6 +279,7 @@ async function init() {
   state.repoOwner = config.repoOwner || detected?.owner || "your-github-username";
   state.repoName = config.repoName || detected?.repo || "your-repo-name";
   state.branch = config.branch || "main";
+  state.useLocalContent = Boolean(config.useLocalContent);
 
   repoLink.href = `https://github.com/${state.repoOwner}/${state.repoName}`;
 
@@ -301,7 +306,7 @@ async function init() {
 
   copyLink.addEventListener("click", async () => {
     try {
-      await navigator.clipboard.writeText(rawUrlForPath(state.currentPath));
+      await navigator.clipboard.writeText(fileUrlForPath(state.currentPath));
       copyLink.textContent = "Copied";
       setTimeout(() => {
         copyLink.textContent = "Copy raw link";

docs/build_tree.py

@@ -1,8 +1,10 @@
 import json
 import os
+import shutil
 
 ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 OUTPUT = os.path.join(ROOT, "docs", "tree.json")
+CONTENT_ROOT = os.path.join(ROOT, "docs", "content")
 EXCLUDE_DIRS = {".git", "docs", "__pycache__"}
 
 
@@ -46,10 +48,33 @@ def build_tree(current_path):
 
 
 def main():
+    if os.path.exists(CONTENT_ROOT):
+        shutil.rmtree(CONTENT_ROOT)
+    os.makedirs(CONTENT_ROOT, exist_ok=True)
+
     tree = build_tree(ROOT)
     with open(OUTPUT, "w", encoding="utf-8") as handle:
         json.dump(tree, handle, indent=2)
+
+    for current_root, dirs, files in os.walk(ROOT):
+        dirs[:] = [d for d in dirs if d not in EXCLUDE_DIRS and not d.startswith(".")]
+        rel_root = os.path.relpath(current_root, ROOT)
+        target_root = os.path.join(CONTENT_ROOT, rel_root)
+        os.makedirs(target_root, exist_ok=True)
+
+        for filename in files:
+            if filename.startswith("."):
+                continue
+            src_path = os.path.join(current_root, filename)
+            rel_path = os.path.relpath(src_path, ROOT)
+            if rel_path.startswith("docs/"):
+                continue
+            dest_path = os.path.join(CONTENT_ROOT, rel_path)
+            os.makedirs(os.path.dirname(dest_path), exist_ok=True)
+            shutil.copy2(src_path, dest_path)
+
     print(f"Wrote {OUTPUT}")
+    print(f"Mirrored content into {CONTENT_ROOT}")
 
 
 if __name__ == "__main__":

docs/config.json

@@ -1,5 +1,6 @@
 {
   "repoOwner": "prakash-sa",
   "repoName": "Competitive-Programming",
-  "branch": "master"
+  "branch": "master",
+  "useLocalContent": true
 }

docs/content/2 Pointers/arrays/1. Two Sum.py

@@ -0,0 +1,40 @@
+# https://leetcode.com/problems/two-sum/description/
+
+'''
+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.
+
+Example 1:
+
+Input: nums = [2,7,11,15], target = 9
+Output: [0,1]
+Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
+Example 2:
+
+Input: nums = [3,2,4], target = 6
+Output: [1,2]
+Example 3:
+
+Input: nums = [3,3], target = 6
+Output: [0,1]
+ 
+
+Constraints:
+
+2 <= nums.length <= 104
+-109 <= nums[i] <= 109
+-109 <= target <= 109
+Only one valid answer exists.
+'''
+
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        freq={}
+        for i,num in enumerate(nums):
+            k=target-num
+            if k in freq:
+                return [i,freq[k]]
+            freq[num]=i
+        return []
+

docs/content/2 Pointers/arrays/11. Container With Most Water.py

@@ -0,0 +1,42 @@
+# https://leetcode.com/problems/container-with-most-water/description/
+
+'''
+You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]).
+Find two lines that together with the x-axis form a container, such that the container contains the most water.
+Return the maximum amount of water a container can store.
+Notice that you may not slant the container.
+
+Example 1:
+Input: height = [1,8,6,2,5,4,8,3,7]
+Output: 49
+Explanation: The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.
+
+Example 2:
+Input: height = [1,1]
+Output: 1
+
+Constraints:
+
+n == height.length
+2 <= n <= 105
+0 <= height[i] <= 104
+'''
+
+from collections import List
+
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        left=0
+        right=len(height)-1
+        ans=0
+        while left<right:
+            h=min(height[left],height[right])
+            ans=max(ans,(right-left)*h)
+            if height[left]>height[right]:
+                right-=1
+            else:
+                left+=1
+        return ans
+        
+# Time Complexity: O(n)
+# Space Complexity: O(1)

docs/content/2 Pointers/arrays/1423. Maximum Points You Can Obtain from Cards.py

@@ -0,0 +1,47 @@
+# https://www.hellointerview.com/learn/code/sliding-window/maximum-points-you-can-obtain-from-cards
+
+'''
+There are several cards arranged in a row, and each card has an associated number of points. The points are given in the integer array cardPoints.
+In one step, you can take one card from the beginning or from the end of the row. You have to take exactly k cards.
+Your score is the sum of the points of the cards you have taken.
+Given the integer array cardPoints and the integer k, return the maximum score you can obtain.
+ 
+
+Example 1:
+Input: cardPoints = [1,2,3,4,5,6,1], k = 3
+Output: 12
+Explanation: After the first step, your score will always be 1. However, choosing the rightmost card first will maximize your total score. The optimal strategy is to take the three cards on the right, giving a final score of 1 + 6 + 5 = 12.
+Example 2:
+Input: cardPoints = [2,2,2], k = 2
+Output: 4
+Explanation: Regardless of which two cards you take, your score will always be 4.
+Example 3:
+Input: cardPoints = [9,7,7,9,7,7,9], k = 7
+Output: 55
+Explanation: You have to take all the cards. Your score is the sum of points of all cards.
+ 
+
+Constraints:
+1 <= cardPoints.length <= 105
+1 <= cardPoints[i] <= 104
+1 <= k <= cardPoints.length
+'''
+from collections import List
+
+class Solution:
+    def maxScore(self, cardPoints: List[int], k: int) -> int:
+        total=sum(cardPoints[:k])
+        ans=total
+        n=len(cardPoints)
+        for i in range(1,k+1):
+            total-=cardPoints[k-i]
+            total+=cardPoints[n-i]
+            ans=max(ans,total)
+        return ans
+    
+    
+# Complexity Analysis
+# Let k be the number of cards we need to select.
+# Time complexity: O(k). We are using two for loops of length k for calculation purposes. This gives us O(2⋅k), which in Big O notation is equal to O(k).
+# Space complexity: O(1). No extra space is used since all the calculations are done impromptu.
+

docs/content/2 Pointers/arrays/15. 3Sum.py

@@ -0,0 +1,71 @@
+# https://leetcode.com/problems/3sum/description/
+
+'''
+Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0.
+Notice that the solution set must not contain duplicate triplets.
+
+Example 1:
+
+Input: nums = [-1,0,1,2,-1,-4]
+Output: [[-1,-1,2],[-1,0,1]]
+Explanation: 
+nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0.
+nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0.
+nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0.
+The distinct triplets are [-1,0,1] and [-1,-1,2].
+Notice that the order of the output and the order of the triplets does not matter.
+
+Example 2:
+Input: nums = [0,1,1]
+Output: []
+Explanation: The only possible triplet does not sum up to 0.
+
+Example 3:
+Input: nums = [0,0,0]
+Output: [[0,0,0]]
+Explanation: The only possible triplet sums up to 0.
+
+Constraints:
+3 <= nums.length <= 3000
+-105 <= nums[i] <= 105
+'''
+
+
+from typing import List
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        res = []
+        n = len(nums)
+
+        for i in range(n):
+            # skip duplicate first numbers
+            if i > 0 and nums[i] == nums[i-1]:
+                continue
+            # optional micro-prune since array is sorted
+            if nums[i] > 0:
+                break
+
+            l, r = i + 1, n - 1
+            while l < r:
+                s = nums[i] + nums[l] + nums[r]
+                if s == 0:
+                    res.append([nums[i], nums[l], nums[r]])
+                    l += 1
+                    r -= 1
+                    # skip duplicates on both sides
+                    while l < r and nums[l] == nums[l-1]:
+                        l += 1
+                    while l < r and nums[r] == nums[r+1]:
+                        r -= 1
+                elif s < 0:
+                    l += 1
+                else:
+                    r -= 1
+        return res
+
+
+# Complexity: O(n^2) time, O(1) extra space (excluding output).
+
+

docs/content/2 Pointers/arrays/167. Two Sum II - Input Array Is Sorted.py

@@ -0,0 +1,60 @@
+# https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/description/
+
+'''
+Given a 1-indexed array of integers numbers that is already sorted in non-decreasing order, find two numbers such that they add up to a specific target number. Let these two numbers be numbers[index1] and numbers[index2] where 1 <= index1 < index2 <= numbers.length.
+Return the indices of the two numbers, index1 and index2, added by one as an integer array [index1, index2] of length 2.
+The tests are generated such that there is exactly one solution. You may not use the same element twice.
+Your solution must use only constant extra space. 
+
+Example 1:
+Input: numbers = [2,7,11,15], target = 9
+Output: [1,2]
+Explanation: The sum of 2 and 7 is 9. Therefore, index1 = 1, index2 = 2. We return [1, 2].
+
+Example 2:
+Input: numbers = [2,3,4], target = 6
+Output: [1,3]
+Explanation: The sum of 2 and 4 is 6. Therefore index1 = 1, index2 = 3. We return [1, 3].
+
+Example 3:
+Input: numbers = [-1,0], target = -1
+Output: [1,2]
+Explanation: The sum of -1 and 0 is -1. Therefore index1 = 1, index2 = 2. We return [1, 2].
+ 
+
+Constraints:
+
+2 <= numbers.length <= 3 * 104
+-1000 <= numbers[i] <= 1000
+numbers is sorted in non-decreasing order.
+-1000 <= target <= 1000
+The tests are generated such that there is exactly one solution.
+'''
+
+
+# The Python Case (No Overflow)
+# Python's standard int type supports arbitrary-precision integers. This means they can grow to be as large as your machine's memory allows, unlike fixed-size integers in languages like C++ (int is typically 32-bit) or Java (int is 32-bit, long is 64-bit).
+
+class Solution:
+    def twoSum(self, numbers: List[int], target: int) -> List[int]:
+        if not numbers:
+            return [-1,-1]
+        left=0
+        right=len(numbers)-1
+        while left<right:
+            k=numbers[left]+numbers[right]
+            if k==target:
+                return [left+1,right+1]
+            elif k<target:
+                left+=1
+            else:
+                right-=1
+        return [-1,-1]
+        
+
+# Complexity Analysis
+# Time complexity: O(n).
+# The input array is traversed at most once. Thus the time complexity is O(n).
+
+# Space complexity: O(1).
+# We only use additional space to store two indices and the sum, so the space complexity is O(1).