#include "gtest/gtest.h"
#include <cmath>

extern "C" int32_t BitCount(uint64_t n);
extern "C" int64_t Factorial(int32_t n);
extern "C" bool IsSquare(int64_t x);
extern "C" int32_t RemoveDigits(int32_t x);
extern "C" int64_t Formula(int64_t x, int64_t n);
extern "C" uint64_t BankDeposit(
    uint64_t initial_sum, int32_t percentage, int32_t years);
extern "C" uint16_t Switch(uint16_t n);
extern "C" uint64_t InfiniteManipulations(uint64_t x);

// ---------------------------------------------------------

namespace {
int32_t OurBitCiount(uint64_t n) {
  int32_t ans = 0;
  while (n != 0) {
    ans += n & 1u;
    n /= 2;
  }
  return ans;
}

int64_t OurFactorial(int32_t n) {
  int64_t ans = 1;
  int64_t step = 1;
  while (ans <= n) {
    ans *= step;
    step++;
  }
  return ans;
}

int32_t OurRemoveDigits(int32_t x) {
  int mn = 1;
  int ans = 0;
  while (x != 0) {
    if ((x % 10) % 2 != 0) {
      ans += mn * (x % 10);
      mn *= 10;
    }
    x /= 10;
  }
  return ans;
}

uint64_t OurBankDeposit(uint64_t initial_sum,
                        int32_t percentage,
                        int32_t years) {
  for (int i = 0; i < years; i++) {
    initial_sum = initial_sum * (100 + percentage) / 100;
  }
  return initial_sum;
}

uint16_t OurSwitch(uint16_t n) {
  uint16_t ans = 0;
  for (int i = 1; i < n; i++) {
    if (n % i == n / i) {
      ans++;
    }
  }
  return ans;
}

uint64_t OurInfiniteManipulations(uint64_t x) {
  uint64_t t = OurBitCiount(x);
  uint64_t f = (1 << t) - 1;

  uint64_t a = 0;
  do {
    a++;
    x /= 2;
  } while (x != 0);

  uint64_t s = f << (a - t);
  return s - f;
}
}

TEST(BitCount, Simple) {
  for (uint32_t i = 0; i < 100000000; i++) {
    if (BitCount(i) != OurBitCiount(i)) {
      std::cerr << i;
    }
    ASSERT_EQ(BitCount(i), OurBitCiount(i));
  }
}

TEST(Factorial, Simple) {
  for (int32_t i = 0; i < 100000000; i++) {
    ASSERT_EQ(Factorial(i), OurFactorial(i));
  }
}

TEST(IsSquare, Simple) {
  for (int i = 0; i < 10000000; i++) {
    int t = std::sqrt(i);
    if ((t * t == i) != IsSquare(i)) {
      std::cerr << i;
    }
    ASSERT_EQ(t * t == i, IsSquare(i));
  }
}

TEST(RemoveDigits, Simple) {
  for (int i = -10000000; i < 10000000; i++) {
    if (OurRemoveDigits(i) != RemoveDigits(i)) {
      std::cerr << i;
    }
    ASSERT_EQ(OurRemoveDigits(i), RemoveDigits(i));
  }
}

TEST(Formula, Simple) {
  EXPECT_EQ(15, Formula(17, 1));
  EXPECT_EQ(3870, Formula(17, 2));
  EXPECT_EQ(-1, Formula(1000, 100));
}

TEST(BankDeposit, Simple) {
  for (int i = 0; i < 300; i++) {
    for (int j = 0; j < 300; j++) {
      for (int z = 0; z < 23; z++) {
        if (OurBankDeposit(i, j, z) != BankDeposit(i, j, z)) {
          std::cerr << i << " " << j << " " << z << '\n';
        }
        ASSERT_EQ(OurBankDeposit(i, j, z), BankDeposit(i, j, z));
      }
    }
  }
}

TEST(Switch, Simple) {
  for (int i = 1; i <= UINT16_MAX; i++) {
    ASSERT_EQ(OurSwitch(i), Switch(i));
  }
}

TEST(InfiniteManipulations, Simple) {
  for (int i = 1; i <= 100000000; i++) {
    ASSERT_EQ(OurInfiniteManipulations(i), InfiniteManipulations(i));
  }
}

// ---------------------------------------------------------