use ranges algorithms in tests for full-range std calls

Apply the same "prefer ranges" convention to the test suite:
- iota(all(x), v)            -> ranges::iota(x, v)
- unique(all(x))            -> begin(ranges::unique(x)) (erase / == end idiom)
- remove_if(all(x), pred)   -> begin(ranges::remove_if(x, pred)) (erase idiom)
- next_permutation(all(x))  -> ranges::next_permutation(x).found

accumulate(all(x), ...) is left as-is: there is no ranges::accumulate in
C++23 (ranges::fold_left would change the idiom), matching how partial_sum
is left in the library.

Author: cameroncuster

tests/library_checker_aizu_tests/data_structures/bit_ordered_set.test.cpp

@@ -17,7 +17,7 @@ int main() {
     compress.push_back(x);
   }
   ranges::sort(compress);
-  compress.erase(unique(all(compress)), end(compress));
+  compress.erase(begin(ranges::unique(compress)), end(compress));
   BIT bit(sz(compress));
   auto get_compressed_idx = [&](int val) -> int {
     int l = 0, r = sz(compress);

tests/library_checker_aizu_tests/data_structures/kth_smallest_pst.test.cpp

@@ -10,7 +10,7 @@ int main() {
   rep(i, 0, n) cin >> arr[i];
   vi sorted(arr);
   ranges::sort(sorted);
-  sorted.erase(unique(all(sorted)), end(sorted));
+  sorted.erase(begin(ranges::unique(sorted)), end(sorted));
   for (int& val : arr) {
     int start = 0, end = sz(sorted);
     while (start + 1 < end) {

tests/library_checker_aizu_tests/data_structures/mode_query.test.cpp

@@ -10,7 +10,7 @@ int main() {
   rep(i, 0, n) cin >> a[i];
   vi comp(a);
   ranges::sort(comp);
-  comp.erase(unique(all(comp)), end(comp));
+  comp.erase(begin(ranges::unique(comp)), end(comp));
   for (int& val : a) {
     int start = 0, end = sz(comp);
     while (start + 1 < end) {

tests/library_checker_aizu_tests/graphs/offline_incremental_scc.test.cpp

@@ -17,7 +17,7 @@ int main() {
   rep(t, 0, m)
     assert((eds[t][0] == eds[t][1]) == (joins[t] == -1));
   vi order(m);
-  iota(all(order), 0);
+  ranges::iota(order, 0);
   ranges::sort(order, {}, [&](int i) { return joins[i]; });
   DSU dsu(n);
   int sum = 0;

tests/library_checker_aizu_tests/handmade_tests/permutation_tree_small.test.cpp

@@ -7,10 +7,10 @@ int main() {
   cin.tie(0)->sync_with_stdio(0);
   for (int n = 1; n <= 8; n++) {
     vi a(n);
-    iota(all(a), 0);
+    ranges::iota(a, 0);
     do {
       perm_tree pt = perm_tree_asserts(a);
-    } while (next_permutation(all(a)));
+    } while (ranges::next_permutation(a).found);
   }
   cout << "Hello World\n";
   return 0;

tests/library_checker_aizu_tests/handmade_tests/rmq_small_n.test.cpp

@@ -20,10 +20,10 @@ int main() {
   cin.tie(0)->sync_with_stdio(0);
   for (int n = 1; n <= 8; n++) {
     vi perm(n);
-    iota(all(perm), 0);
+    ranges::iota(perm, 0);
     do {
       test_all_subarrays(perm);
-    } while (next_permutation(all(perm)));
+    } while (ranges::next_permutation(perm).found);
   }
   for (int n = 1; n <= 100; n++) {
     rep(times, 0, 40) {

tests/library_checker_aizu_tests/handmade_tests/seg_tree_find.test.cpp

@@ -51,7 +51,7 @@ int main() {
       else assert(cur_le == prv_ri);
     }
     ranges::sort(rngs);
-    assert(unique(all(rngs)) == end(rngs));
+    assert(begin(ranges::unique(rngs)) == end(rngs));
     reset();
     assert(
       pos == rv(rev.find_last(rv(r - 1), rv(l) + 1, f)));
@@ -67,7 +67,7 @@ int main() {
       else assert(prv_le == cur_ri);
     }
     ranges::sort(rngs);
-    assert(unique(all(rngs)) == end(rngs));
+    assert(begin(ranges::unique(rngs)) == end(rngs));
   }
   cout << "Hello World\n";
   return 0;

tests/library_checker_aizu_tests/mono_st_asserts.hpp

@@ -11,7 +11,7 @@ tuple<int, vector<vi>, vi> min_cartesian_tree(const vi& a,
     return r[i] == n || a[r[i]] < a[i];
   };
   vi to_min(n);
-  iota(all(to_min), 0);
+  ranges::iota(to_min, 0);
   for (int i = n - 1; i >= 0; i--)
     if (!is_node(i)) to_min[i] = to_min[r[i]];
   vector<vi> adj(n);

tests/library_checker_aizu_tests/strings/sa_sort_pairs.test.cpp

@@ -10,7 +10,7 @@ int main() {
   for (int& x : arr) cin >> x;
   vi compress(arr);
   ranges::sort(compress);
-  compress.erase(unique(all(compress)), end(compress));
+  compress.erase(begin(ranges::unique(compress)), end(compress));
   for (int& x : arr) {
     int l = -1, r = int(sz(compress));
     while (r - l > 1) {
@@ -24,7 +24,7 @@ int main() {
   auto [sa, sa_inv, lcp] = get_sa(arr, int(sz(compress)));
   sa_query lq(arr, sa, sa_inv, lcp);
   vi idxs(n);
-  iota(all(idxs), 0);
+  ranges::iota(idxs, 0);
   ranges::sort(idxs, [&](int i, int j) -> bool {
     return lq.cmp_substrs(2 * i, 2 * (i + 1), 2 * j,
              2 * (j + 1)) < 0;

tests/library_checker_aizu_tests/strings/single_matching_bs.test.cpp

@@ -70,8 +70,8 @@ int main() {
       vi matches_other(begin(lq_both.sa) + sa_le2,
         begin(lq_both.sa) + sa_ri2);
       matches_other.erase(
-        remove_if(all(matches_other),
-          [&](int val) { return val >= sz(s) + 1; }),
+        begin(ranges::remove_if(matches_other,
+          [&](int val) { return val >= sz(s) + 1; })),
         end(matches_other));
       ranges::sort(matches_other);
       assert(matches == matches_other);