feat: Introduce AddGroup for flexible operations and refactor StaticRangeSum to utilize it

Author: weilycoder

test/static_range_sum.test.cpp

@@ -17,7 +17,7 @@ int main() {
   for (size_t i = 0; i < n; ++i)
     cin >> arr[i];
 
-  StaticRangeSum<uint64_t> sum(arr);
+  StaticRangeSum<AddGroup<uint64_t>> sum(arr);
   while (q--) {
     size_t l, r;
     cin >> l >> r;

weilycoder/ds/group.hpp

@@ -0,0 +1,11 @@
+#ifndef WEILYCODER_GROUP_HPP
+#define WEILYCODER_GROUP_HPP
+
+template <typename T> struct AddGroup {
+  using value_type = T;
+  static constexpr T operation(const T &a, const T &b) { return a + b; }
+  static constexpr T identity() { return T{}; }
+  static constexpr T inverse(const T &a) { return -a; }
+};
+
+#endif

weilycoder/ds/static_range_sum.hpp

@@ -1,19 +1,41 @@
 #ifndef WEILYCODER_STATIC_RANGE_SUM_HPP
 #define WEILYCODER_STATIC_RANGE_SUM_HPP
 
+#include "group.hpp"
 #include <cstddef>
+#include <stdexcept>
 #include <vector>
 
 namespace weilycoder {
-template <typename T, typename ptr_t = size_t> struct StaticRangeSum {
+template <typename Group> struct StaticRangeSum {
+  using value_type = typename Group::value_type;
+  using T = value_type;
+
+private:
   std::vector<T> prefix_sum;
 
-  StaticRangeSum(const std::vector<T> &data) : prefix_sum(data.size() + 1) {
-    for (ptr_t i = 1; i <= data.size(); ++i)
-      prefix_sum[i] = prefix_sum[i - 1] + data[i - 1];
+public:
+  explicit StaticRangeSum(const std::vector<T> &data)
+      : prefix_sum(data.size() + 1, Group::identity()) {
+    for (size_t i = 1; i <= data.size(); ++i)
+      prefix_sum[i] = Group::operation(prefix_sum[i - 1], data[i - 1]);
+  }
+
+  template <typename InputIt>
+  StaticRangeSum(InputIt first, InputIt last)
+      : prefix_sum(std::distance(first, last) + 1, Group::identity()) {
+    size_t i = 1;
+    for (auto it = first; it != last; ++it, ++i)
+      prefix_sum[i] = Group::operation(prefix_sum[i - 1], *it);
   }
 
-  T query(ptr_t l, ptr_t r) const { return prefix_sum[r] - prefix_sum[l]; }
+  size_t size() const { return prefix_sum.size() - 1; }
+
+  T query(size_t l, size_t r) const {
+    if (l > r || r > size())
+      throw std::out_of_range("Invalid range for StaticRangeSum query");
+    return Group::operation(Group::inverse(prefix_sum[l]), prefix_sum[r]);
+  }
 };
 } // namespace weilycoder