#include <chrono>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <string>

// KuuHaKu's solution
size_t get_price_kuu(size_t has, size_t wants) {
  size_t i{has / 10 + 1 | 0};
  size_t cost{0};

  size_t step{10 - has % 10};
  while (wants >= 10) {
    cost += step * i++;
    wants -= step;
    step = 10;
  }

  const size_t cost_mult{has / i | 0};

  return cost + cost_mult - (has % 10) + wants * ++i;
}

// Tim's solution
size_t get_price_tim(size_t has, size_t wants) {
  const short base_price{1};
  const short step{10};
  const size_t first{std::min(step - has % step, wants)};
  const size_t second{wants - first - (wants - first) % step};
  const size_t third{wants - first - second};

  size_t out{static_cast<size_t>(
      first * (base_price * std::ceil(has / static_cast<double>(step))))};

  if (second != 0) {
    const size_t iterations{second / step};
    const size_t multiplier{base_price * ((has + first) / step) + 1};

    for (size_t i{0}; i < iterations; i++) {
      const size_t current{multiplier + i};

      out += current * step;
    }
  }

  if (third != 0) {
    const size_t current{base_price * ((has + first + second) / step) + 1};

    out += third * current;
  }

  return out;
}

// Ben's solution
size_t get_price_ben(size_t has, size_t wants) {
  size_t inventory_count_tracker{has};
  size_t cost_tracker{0};
  size_t current_cost{
      static_cast<size_t>(std::floor(inventory_count_tracker / 10) + 1)};

  if (inventory_count_tracker % 10 != 0) {
    const size_t remaining_count{10 - (inventory_count_tracker % 10)};

    cost_tracker += current_cost * remaining_count;
    inventory_count_tracker += remaining_count;
    current_cost++;
  }

  const size_t final_inventory_size{has + wants};
  const size_t final_inventory_size_minus_10{final_inventory_size - 10};

  for (; inventory_count_tracker < final_inventory_size_minus_10;
       inventory_count_tracker += 10) {
    cost_tracker += current_cost * 10;
    current_cost++;
  }

  const size_t remaining_count{final_inventory_size - inventory_count_tracker};

  cost_tracker += current_cost * remaining_count;

  return cost_tracker;
}

// ---

void benchmark(size_t (*func)(size_t, size_t), std::string_view name) {
  auto start = std::chrono::high_resolution_clock::now();

  for (unsigned int i{0}; i < 999'999; i++) {
    [[maybe_unused]] volatile auto foo = func(std::rand(), std::rand());
  }

  auto end = std::chrono::high_resolution_clock::now();

  std::cout << name << " solution took: "
            << std::chrono::duration_cast<std::chrono::milliseconds>(end -
                                                                     start)
                   .count()
            << "ms\n";
}

int main() {
  std::srand(std::time(nullptr));

  benchmark(get_price_kuu, "KuuHaKu's");
  benchmark(get_price_tim, "Tim's");
  benchmark(get_price_ben, "Ben's");
}