tests/is_partitioned.test.cpp

• View this file on GitHub
• Last update: 2025-05-10 15:13:30+09:00

Depends on

• Assertion macro (tools/assert_that.hpp)
• Check whether a given boolean function is partitioned (tools/is_partitioned.hpp)

Code

// competitive-verifier: STANDALONE

#include <iostream>
#include <vector>
#include "tools/assert_that.hpp"
#include "tools/is_partitioned.hpp"

int main() {
  std::cin.tie(nullptr);
  std::ios_base::sync_with_stdio(false);

  assert_that(tools::is_partitioned(0, 0, [](const auto i) -> bool { return std::vector<bool>{false}[i]; }));
  assert_that(tools::is_partitioned(0, 0, [](const auto i) -> bool { return std::vector<bool>{true}[i]; }));
  assert_that(tools::is_partitioned(0, 1, [](const auto i) -> bool { return std::vector<bool>{false, false}[i]; }));
  assert_that(tools::is_partitioned(0, 1, [](const auto i) -> bool { return std::vector<bool>{true, false}[i]; }));
  assert_that(tools::is_partitioned(0, 1, [](const auto i) -> bool { return std::vector<bool>{false, true}[i]; }));
  assert_that(tools::is_partitioned(0, 1, [](const auto i) -> bool { return std::vector<bool>{true, true}[i]; }));
  assert_that(tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{false, false, false}[i]; }));
  assert_that(tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{true, false, false}[i]; }));
  assert_that(!tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{false, true, false}[i]; }));
  assert_that(tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{true, true, false}[i]; }));
  assert_that(tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{false, false, true}[i]; }));
  assert_that(!tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{true, false, true}[i]; }));
  assert_that(tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{false, true, true}[i]; }));
  assert_that(tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{true, true, true}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, false, false, false}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, false, false, false}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, true, false, false}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, true, false, false}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, false, true, false}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, false, true, false}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, true, true, false}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, true, true, false}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, false, false, true}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, false, false, true}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, true, false, true}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, true, false, true}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, false, true, true}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, false, true, true}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, true, true, true}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, true, true, true}[i]; }));

  return 0;
}

#line 1 "tests/is_partitioned.test.cpp"
// competitive-verifier: STANDALONE

#include <iostream>
#include <vector>
#line 1 "tools/assert_that.hpp"



#line 5 "tools/assert_that.hpp"
#include <cstdlib>

#define assert_that_impl(cond, file, line, func) do {\
  if (!cond) {\
    ::std::cerr << file << ':' << line << ": " << func << ": Assertion `" << #cond << "' failed." << '\n';\
    ::std::exit(EXIT_FAILURE);\
  }\
} while (false)
#define assert_that(...) assert_that_impl((__VA_ARGS__), __FILE__, __LINE__, __func__)


#line 1 "tools/is_partitioned.hpp"



#include <cassert>

namespace tools {
  template <typename T, typename F>
  bool is_partitioned(const T l, const T r, const F& f) {
    assert(l <= r);

    if (r - l <= 1) return true;

    const bool f_l = f(l);
    T m;
    for (m = l + 1; m <= r && f(m) == f_l; ++m);
    if (r < m) return true;

    for (++m; m <= r && f(m) != f_l; ++m);
    if (r < m) return true;

    return false;
  }
}


#line 7 "tests/is_partitioned.test.cpp"

int main() {
  std::cin.tie(nullptr);
  std::ios_base::sync_with_stdio(false);

  assert_that(tools::is_partitioned(0, 0, [](const auto i) -> bool { return std::vector<bool>{false}[i]; }));
  assert_that(tools::is_partitioned(0, 0, [](const auto i) -> bool { return std::vector<bool>{true}[i]; }));
  assert_that(tools::is_partitioned(0, 1, [](const auto i) -> bool { return std::vector<bool>{false, false}[i]; }));
  assert_that(tools::is_partitioned(0, 1, [](const auto i) -> bool { return std::vector<bool>{true, false}[i]; }));
  assert_that(tools::is_partitioned(0, 1, [](const auto i) -> bool { return std::vector<bool>{false, true}[i]; }));
  assert_that(tools::is_partitioned(0, 1, [](const auto i) -> bool { return std::vector<bool>{true, true}[i]; }));
  assert_that(tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{false, false, false}[i]; }));
  assert_that(tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{true, false, false}[i]; }));
  assert_that(!tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{false, true, false}[i]; }));
  assert_that(tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{true, true, false}[i]; }));
  assert_that(tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{false, false, true}[i]; }));
  assert_that(!tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{true, false, true}[i]; }));
  assert_that(tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{false, true, true}[i]; }));
  assert_that(tools::is_partitioned(0, 2, [](const auto i) -> bool { return std::vector<bool>{true, true, true}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, false, false, false}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, false, false, false}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, true, false, false}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, true, false, false}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, false, true, false}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, false, true, false}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, true, true, false}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, true, true, false}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, false, false, true}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, false, false, true}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, true, false, true}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, true, false, true}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, false, true, true}[i]; }));
  assert_that(!tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, false, true, true}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{false, true, true, true}[i]; }));
  assert_that(tools::is_partitioned(0, 3, [](const auto i) -> bool { return std::vector<bool>{true, true, true, true}[i]; }));

  return 0;
}

Back to top page