Attempt update extract_snippets.py accepting spaces at beginning

mhayter · mhayter · commit 08b1de3464d1 · 2025-12-05T23:27:49.000-08:00
diff --git a/src/data_structures/fenwick.md b/src/data_structures/fenwick.md
@@ -166,36 +166,36 @@ You can create a Fenwick tree initialized with zeros, or you can convert an exis
 
 === "C++"
 ```{.cpp file=fenwick_sum}
-struct FenwickTree {
-	vector<int> bit;  // binary indexed tree
-	int n;
-
-	FenwickTree(int n) {
-		this->n = n;
-		bit.assign(n, 0);
-	}
-
-	FenwickTree(vector<int> const &a) : FenwickTree(a.size()) {
-		for (size_t i = 0; i < a.size(); i++)
-			add(i, a[i]);
-	}
-
-	int sum(int r) {
-		int ret = 0;
-		for (; r >= 0; r = (r & (r + 1)) - 1)
-			ret += bit[r];
-		return ret;
-	}
-
-	int sum(int l, int r) {
-		return sum(r) - sum(l - 1);
-	}
-
-	void add(int idx, int delta) {
-		for (; idx < n; idx = idx | (idx + 1))
-			bit[idx] += delta;
-	}
-};
+    struct FenwickTree {
+    	vector<int> bit;  // binary indexed tree
+    	int n;
+
+    	FenwickTree(int n) {
+    		this->n = n;
+    		bit.assign(n, 0);
+    	}
+
+    	FenwickTree(vector<int> const &a) : FenwickTree(a.size()) {
+    		for (size_t i = 0; i < a.size(); i++)
+    			add(i, a[i]);
+    	}
+
+    	int sum(int r) {
+    		int ret = 0;
+    		for (; r >= 0; r = (r & (r + 1)) - 1)
+    			ret += bit[r];
+    		return ret;
+    	}
+
+    	int sum(int l, int r) {
+    		return sum(r) - sum(l - 1);
+    	}
+
+    	void add(int idx, int delta) {
+    		for (; idx < n; idx = idx | (idx + 1))
+    			bit[idx] += delta;
+    	}
+    };
 ```
 === "Python"
     ```py
@@ -254,33 +254,33 @@ Both significant limitations are because the $min$ operation together with the s
 
 === "C++"
 ```{.cpp file=fenwick_min}
-struct FenwickTreeMin {
-	vector<int> bit;
-	int n;
-	const int INF = (int)1e9;
-
-	FenwickTreeMin(int n) {
-		this->n = n;
-		bit.assign(n, INF);
-	}
-
-	FenwickTreeMin(vector<int> a) : FenwickTreeMin(a.size()) {
-		for (size_t i = 0; i < a.size(); i++)
-			update(i, a[i]);
-	}
-
-	int getmin(int r) {
-		int ret = INF;
-		for (; r >= 0; r = (r & (r + 1)) - 1)
-			ret = min(ret, bit[r]);
-		return ret;
-	}
-
-	void update(int idx, int val) {
-		for (; idx < n; idx = idx | (idx + 1))
-			bit[idx] = min(bit[idx], val);
-	}
-};
+    struct FenwickTreeMin {
+    	vector<int> bit;
+    	int n;
+    	const int INF = (int)1e9;
+
+    	FenwickTreeMin(int n) {
+    		this->n = n;
+    		bit.assign(n, INF);
+    	}
+
+    	FenwickTreeMin(vector<int> a) : FenwickTreeMin(a.size()) {
+    		for (size_t i = 0; i < a.size(); i++)
+    			update(i, a[i]);
+    	}
+
+    	int getmin(int r) {
+    		int ret = INF;
+    		for (; r >= 0; r = (r & (r + 1)) - 1)
+    			ret = min(ret, bit[r]);
+    		return ret;
+    	}
+
+    	void update(int idx, int val) {
+    		for (; idx < n; idx = idx | (idx + 1))
+    			bit[idx] = min(bit[idx], val);
+    	}
+    };
 ```
 === "Python"
     ```py
@@ -436,39 +436,39 @@ As you can see, the main benefit of this approach is that the binary operations
 The following implementation can be used like the other implementations, however it uses one-based indexing internally.
 
 === "C++"
-```{.cpp file=fenwick_sum_onebased}
-struct FenwickTreeOneBasedIndexing {
-	vector<int> bit;  // binary indexed tree
-	int n;
-
-	FenwickTreeOneBasedIndexing(int n) {
-		this->n = n + 1;
-		bit.assign(n + 1, 0);
-	}
-
-	FenwickTreeOneBasedIndexing(vector<int> a)
-		: FenwickTreeOneBasedIndexing(a.size()) {
-		for (size_t i = 0; i < a.size(); i++)
-			add(i, a[i]);
-	}
-
-	int sum(int idx) {
-		int ret = 0;
-		for (++idx; idx > 0; idx -= idx & -idx)
-			ret += bit[idx];
-		return ret;
-	}
-
-	int sum(int l, int r) {
-		return sum(r) - sum(l - 1);
-	}
-
-	void add(int idx, int delta) {
-		for (++idx; idx < n; idx += idx & -idx)
-			bit[idx] += delta;
-	}
-};
-```
+    ```{.cpp file=fenwick_sum_onebased}
+    struct FenwickTreeOneBasedIndexing {
+    	vector<int> bit;  // binary indexed tree
+    	int n;
+
+    	FenwickTreeOneBasedIndexing(int n) {
+    		this->n = n + 1;
+    		bit.assign(n + 1, 0);
+    	}
+
+    	FenwickTreeOneBasedIndexing(vector<int> a)
+    		: FenwickTreeOneBasedIndexing(a.size()) {
+    		for (size_t i = 0; i < a.size(); i++)
+    			add(i, a[i]);
+    	}
+
+    	int sum(int idx) {
+    		int ret = 0;
+    		for (++idx; idx > 0; idx -= idx & -idx)
+    			ret += bit[idx];
+    		return ret;
+    	}
+
+    	int sum(int l, int r) {
+    		return sum(r) - sum(l - 1);
+    	}
+
+    	void add(int idx, int delta) {
+    		for (++idx; idx < n; idx += idx & -idx)
+    			bit[idx] += delta;
+    	}
+    };
+    ```
 === "Python"
     ```py
     class FenwickTreeOneBasedIndexing:
diff --git a/test/extract_snippets.py b/test/extract_snippets.py
@@ -12,7 +12,7 @@ def extract_tests(filepath):
     filepath_short = os.path.basename(filepath) 
     article_name = filepath_short.split('.')[0]
 
-    snippet_start = re.compile(r"^```\{.cpp\s+file=(\S+)\}$")
+    snippet_start = re.compile(r"^\s*```\{.cpp\s+file=(\S+)\}$")
     snippet_end = re.compile(r"^```$")
 
     with open(filepath) as f:
