Day23 Test, C++ (clang)

Language: Layout:

#include <iostream>
#include <map>
#include <string>
#include <vector>

std::vector<std::string> split(const std::string& text, const std::string& delims) {
  std::vector<std::string> tokens;
  std::size_t              start = text.find_first_not_of(delims), end = 0;
  while ((end = text.find_first_of(delims, start)) != std::string::npos) {
    if (end != start)
      tokens.push_back(text.substr(start, end - start));
    start = text.find_first_not_of(delims, end);
  }
  if (start != std::string::npos)
    tokens.push_back(text.substr(start));
  return tokens;
}

enum ParamType { Reg, Imm };

struct Param {
  ParamType t{Reg};
  int       v{' '};
};

class Assembunny;

struct Instruction {
  Assembunny* interpreter{nullptr};
  char        c{'-'};
  Param       p[2];

int& reg(int);
  int  val(int);
};

class Assembunny {
  std::map<char, int> regs;
  std::vector<Instruction> ins;
  char invert(char);

public:
  Assembunny(std::istream& is);
  Assembunny& optAdd();
  Assembunny& optMul();
  Assembunny& run();
  Assembunny& set(char, int);
  int  get(char);
  int& ref(char);
};

int dummy;

int& Instruction::reg(int idx) {
  if (p[idx].t == Reg)
    return interpreter->ref(p[idx].v);
  return dummy;
}

int Instruction::val(int idx) {
  if (p[idx].t == Reg)
    return interpreter->get(p[idx].v);
  return p[idx].v;
}

Assembunny::Assembunny(std::istream& is) {
  for (std::string line; std::getline(is, line); ) {
    const auto& tok = split(line, " ");
    Instruction in{this, tok[0][0], {}};
    for (unsigned int i{0}; i < tok.size() - 1; ++i) {
      bool isR{tok[i + 1][0] >= 'a' && tok[i + 1][0] <= 'd'};
      in.p[i] = {isR ? Reg : Imm, isR ? tok[i + 1][0] : std::stoi(tok[i + 1])};
    }
    ins.push_back(in);
  }
}

Assembunny& Assembunny::optMul() {
  for (unsigned int p{5}; p < ins.size(); ++p) {
    using IP = const Instruction*;
    IP c = &ins[p - 5], i = &ins[p - 4], d1 = &ins[p - 3], j1 = &ins[p - 2], d2 = &ins[p - 1], j2 = &ins[p];
    if (c->c == 'c' && i->c == 'i' && d1->c == 'd' && j1->c == 'j' && d2->c == 'd' && j2->c == 'j'
        && j1->p[1].v == -2 && j2->p[1].v == -5
        && j1->p[0].v == d1->p[0].v && j2->p[0].v == d2->p[0].v) {
      int marg1{c->p[0].v}, marg2{j2->p[0].v}, res{i->p[0].v}, reset{c->p[1].v};
      ins[p - 5] = {this, 'm', {{Reg, marg1}, {Reg, marg2}}};
      ins[p - 4] = {this, 'a', {{Reg, marg2}, {Reg, res}}};
      ins[p - 3] = {this, 'c', {{Imm, 0}, {Reg, marg2}}};
      ins[p - 2] = {this, 'c', {{Imm, 0}, {Reg, reset}}};
      ins[p - 1] = {this, 'n', {{}, {}}};
      ins[p - 0] = {this, 'n', {{}, {}}};
    }
  }
  return *this;
}

Assembunny& Assembunny::optAdd() {
  for (unsigned int p{2}; p < ins.size(); ++p) {
    using IP = const Instruction*;
    IP i = &ins[p - 2], d = &ins[p - 1], j = &ins[p];
    if (i->c == 'i' && d->c == 'd' && j->c == 'j' && j->p[1].v == -2 && d->p[0].v == j->p[0].v) {
      ins[p - 2] = {this, 'a', {{Reg, d->p[0].v}, {Reg, i->p[0].v}}};
      ins[p - 1] = {this, 'c', {{Imm, 0}, {Reg, d->p[0].v}}};
      ins[p - 0] = {this, 'n', {{}, {}}};
    }
  }
  return *this;
}

char Assembunny::invert(char i) {
  switch (i) {
    case 'i':
      return 'd';
    case 't':
    case 'd':
      return 'i';
    case 'j':
      return 'c';
    case 'c':
      return 'j';
    default:
      return i;
  }
}

Assembunny& Assembunny::run()
{
  for (int pc{0}; pc < int(ins.size()); ++pc) {
    auto& i = ins[pc];
    switch (i.c) {
      case 't':
        if (pc + i.val(0) >= 0 && pc + i.val(0) < int(ins.size()))
          ins[pc + i.val(0)].c = invert(ins[pc + i.val(0)].c);
        break;
      case 'i':
        ++i.reg(0);
        break;
      case 'd':
        --i.reg(0);
        break;
      case 'c':
        i.reg(1) = i.val(0);
        break;
      case 'j':
        pc += (i.val(0) != 0) * (i.val(1) - 1);
        break;
      case 'm':
        i.reg(1) *= i.val(0);
        break;
      case 'a':
        i.reg(1) += i.val(0);
        break;
      default:
        break;
    }
  }
  return *this;
}

int& Assembunny::ref(char c) {
  return regs[c];
}

int Assembunny::get(char c) {
  return ref(c);
}

Assembunny& Assembunny::set(char c, int v) {
  ref(c) = v;
  return *this;
}

int main() {
  Assembunny ab{std::cin};
  ab.set('a', 12).set('b', 0).set('c', 0).set('d', 0);
  ab.optMul().optAdd().run();
  std::cout << ab.get('a') << std::endl;
}

Show compiler warnings [ + ] Compiler args [ - ] Show input
Compilation time: 0.82 sec, absolute running time: 0.14 sec, cpu time: 0 sec, memory peak: 3 Mb, absolute service time: 0,96 sec