Update fenwick.md

mhayter · web-flow · commit f5cf5ec19e51 · 2025-12-05T22:29:22.000-08:00
pretty sure spaces are screwing up test file generation.
diff --git a/src/data_structures/fenwick.md b/src/data_structures/fenwick.md
@@ -253,35 +253,35 @@ Additionally, each time a value is `update`'d, the new value has to be smaller t
 Both significant limitations are because the $min$ operation together with the set of integers doesn't form a group, as there are no inverse elements.
 
 === "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);
-        }
+```{.cpp file=fenwick_min}
+struct FenwickTreeMin {
+	vector<int> bit;
+	int n;
+	const int INF = (int)1e9;
 
-        FenwickTreeMin(vector<int> a) : FenwickTreeMin(a.size()) {
-            for (size_t i = 0; i < a.size(); i++)
-                update(i, a[i]);
-        }
+	FenwickTreeMin(int n) {
+		this->n = n;
+		bit.assign(n, INF);
+	}
 
-        int getmin(int r) {
-            int ret = INF;
-            for (; r >= 0; r = (r & (r + 1)) - 1)
-                ret = min(ret, bit[r]);
-            return ret;
-        }
+	FenwickTreeMin(vector<int> a) : FenwickTreeMin(a.size()) {
+		for (size_t i = 0; i < a.size(); i++)
+			update(i, a[i]);
+	}
 
-        void update(int idx, int val) {
-            for (; idx < n; idx = idx | (idx + 1))
-                bit[idx] = min(bit[idx], val);
-        }
-    };
-    ```
+	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
     class FenwickTreeMin:
@@ -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);
-        }
+```{.cpp file=fenwick_sum_onebased}
+struct FenwickTreeOneBasedIndexing {
+	vector<int> bit;  // binary indexed tree
+	int n;
 
-        FenwickTreeOneBasedIndexing(vector<int> a)
-            : FenwickTreeOneBasedIndexing(a.size()) {
-            for (size_t i = 0; i < a.size(); i++)
-                add(i, a[i]);
-        }
+	FenwickTreeOneBasedIndexing(int n) {
+		this->n = n + 1;
+		bit.assign(n + 1, 0);
+	}
 
-        int sum(int idx) {
-            int ret = 0;
-            for (++idx; idx > 0; idx -= idx & -idx)
-                ret += bit[idx];
-            return ret;
-        }
+	FenwickTreeOneBasedIndexing(vector<int> a)
+		: FenwickTreeOneBasedIndexing(a.size()) {
+		for (size_t i = 0; i < a.size(); i++)
+			add(i, a[i]);
+	}
 
-        int sum(int l, int r) {
-            return sum(r) - sum(l - 1);
-        }
+	int sum(int idx) {
+		int ret = 0;
+		for (++idx; idx > 0; idx -= idx & -idx)
+			ret += bit[idx];
+		return ret;
+	}
 
-        void add(int idx, int delta) {
-            for (++idx; idx < n; idx += idx & -idx)
-                bit[idx] += delta;
-        }
-    };
-    ```
+	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:
