Оптимизировать алгоритм

#include <string>
#include <vector>
std::string who_is_next(std::vector<std::string> &names, long long r) {
for (int i = r;; --i) {
if (i == 1)  { return names[0]; }
else{ names.vector::push_back(names[0]); names.vector::push_back(names[0]);names.erase(names.begin());}}}

std::vector<std::string> names = {"Sheldon", "Leonard", "Penny", "Rajesh", "Howard"};  
        Assert::That(who_is_next(names, 1), Equals("Sheldon"));
        Assert::That(who_is_next(names, 52), Equals("Penny"));
        Assert::That(who_is_next(names, 10010), Equals("Howard"));

string[] names = new string[] { "Sheldon", "Leonard", "Penny", "Rajesh", "Howard" };
Line.WhoIsNext(names, 1) == "Sheldon"
Line.WhoIsNext(names, 52) == "Penny"
Line.WhoIsNext(names, 7230702951) == "Leonard"

#include <chrono>
#include <deque>
#include <functional>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
 
std::string who_is_next(std::vector<std::string> names, long long r) {
  for (int i = r;; --i) {
    if (i == 1) {
      return names[0];
    } else {
      names.vector::push_back(names[0]);
      names.vector::push_back(names[0]);
      names.erase(names.begin());
    }
  }
}
 
std::string who_is_next_deque(std::vector<std::string> names, long long n) {
  std::deque<std::string> names_deque(names.begin(), names.end());
  for (long long i = 1; i < n; ++i) {
    names_deque.push_back(names_deque.front());
    names_deque.push_back(names_deque.front());
    names_deque.pop_front();
  }
  return names_deque.front();
}
 
std::string who_is_next_deque_idxs(std::vector<std::string> names,
                                   long long n) {
  std::deque<int> names_deque(names.size());
  std::iota(names_deque.begin(), names_deque.end(), 0);
  for (long long i = 1; i < n; ++i) {
    names_deque.push_back(names_deque.front());
    names_deque.push_back(names_deque.front());
    names_deque.pop_front();
  }
  return names[names_deque.front()];
}
 
std::string who_is_next_deque_idxs_compressed(std::vector<std::string> names,
                                              long long n) {
  std::deque<std::pair<int, int>> names_deque(names.size());
  for (size_t i = 0; i < names_deque.size(); ++i) {
    names_deque[i].first = i;
    // В начале все в единственном экземпляре
    names_deque[i].second = 1;
  }
  for (long long i = 1; i < n; ++i) {
    auto& head = names_deque.front();
    auto& tail = names_deque.back();
    if (tail.first == head.first) {
      tail.second += 2;
    } else {
      names_deque.emplace_back(head.first, 2);
    }
    if (head.second > 1) {
      --head.second;
    } else {
      names_deque.pop_front();
    }
  }
  return names[names_deque.front().first];
}
 
using Names = std::vector<std::string>;
 
void run_test(std::function<std::string(Names&, long long)> func,
              Names& names,
              long long n,
              std::string expected) {
  const auto begin = std::chrono::steady_clock::now();
  const auto result = func(names, n);
  const auto end = std::chrono::steady_clock::now();
  const auto elapsed =
      std::chrono::duration_cast<std::chrono::microseconds>(end - begin);
  const std::string status = result == expected ? "Ok" : "Fail";
  std::cout << status << " - " << elapsed.count() << " us\n";
}
 
void run_tests(std::string title,
               std::function<std::string(Names&, long long)> func) {
  Names names = {"Sheldon", "Leonard", "Penny", "Rajesh", "Howard"};
 
  std::cout << title << "\n";
  run_test(func, names, 1, "Sheldon");
  run_test(func, names, 52, "Penny");
  run_test(func, names, 10010, "Howard");
  run_test(func, names, 101000, "Leonard");
  std::cout << "\n";
}
 
int main() {
  run_tests("Origin by plzvtl", who_is_next);
  run_tests("Simple with dequeue", who_is_next_deque);
  run_tests("Simple with dequeue idxs", who_is_next_deque_idxs);
  run_tests("Compressed with dequeue idxs", who_is_next_deque_idxs_compressed);
}

 names.erase(names.begin(), names.begin() + i);

int log2(int x)
{
    int ret = 0;
    while (x >>= 1) ret++;
    
    return ret;
}
 
int index(int n)
{
    int l2 = log2(n / 5 + 1);
    int w = 1 << l2;
    int b = 5 * (w - 1);
    return (n - b) / w;
}
 
#include <iostream>
using namespace std;
 
int main()
{
    const char* names[] = { "Sheldon", "Leonard", "Penny", "Rajesh", "Howard" };
    for (int n = 0; n < 100; n++)
        cout << names[index(n)] << endl;
}

std::string who_is_next_deque_idxs_compressed(std::vector<std::string> names, long long n) 
{
    std::vector<std::pair<size_t, int>> names_deque;
    names_deque.reserve(names.size() + n);
    for (size_t i = 0; i < names.size(); ++i)
        names_deque.emplace_back(i, 1);
 
    size_t idx = 0;
    for (long long i = 1; i < n; ++i) 
    {
        auto& head = names_deque[idx];
        auto& tail = names_deque.back();
        if (tail.first == head.first) 
            tail.second += 2;
        else 
            names_deque.emplace_back(head.first, 2);
 
        if (head.second > 1) 
            --head.second;
        else 
            ++idx;
    }
    return names[names_deque[idx].first];
}