LeetCode/problems/spiral-matrix.cpp

#include <cassert>
#include <vector>

class Solution {
  struct indices {
    int x;
    int y;

    bool operator==(const indices& other) const = default;
    indices& operator+=(const indices& other) {
      x += other.x;
      y += other.y;
      return *this;
    }

    friend indices operator+(indices left, const indices& right) {
      return left += right;
    }

    int operator[](const std::vector<std::vector<int>>& mat) const {
      return mat[y][x];
    }
  };

  struct spiral_indices {
    spiral_indices(const std::vector<std::vector<int>>& matrix)
        : x_bounds{-1, static_cast<int>(matrix[0].size())},
          y_bounds{-1, static_cast<int>(matrix.size())} {}

    bool done() const { return !in_bounds(idx); }

    spiral_indices& operator++() {
      // update bounds and change the direction if cannot move
      if (!in_bounds(idx + d)) {
        // change the direction
        d = {-d.y, d.x};

        // get the magnitude of the vector
        auto flat_d = d.x + d.y;

        // decide whether we're moving x or y bounds
        auto& bounds = d.x ? x_bounds : y_bounds;
        if (flat_d > 0) {
          bounds.x++;
        } else {
          bounds.y--;
        }
      }

      idx += d;

      return *this;
    }

    int operator[](const std::vector<std::vector<int>>& mat) const {
      return idx[mat];
    }

   private:
    indices idx{0, 0};
    indices d{1, 0};
    indices x_bounds, y_bounds;

    bool in_bounds(const indices& idx) const {
      return (x_bounds.x < idx.x && idx.x < x_bounds.y) &&
             (y_bounds.x < idx.y && idx.y < y_bounds.y);
    }
  };

 public:
  std::vector<int> spiralOrder(const std::vector<std::vector<int>>& matrix) {
    std::vector<int> spiral;

    for (spiral_indices idx{matrix}; !idx.done(); ++idx) {
      spiral.push_back(idx[matrix]);
    }

    return spiral;
  }
};

int main() {
  Solution s;

  assert((s.spiralOrder({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}) ==
          std::vector{1, 2, 3, 6, 9, 8, 7, 4, 5}));
  assert((s.spiralOrder({{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}) ==
          std::vector{1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7}));

  return 0;
}