text: /**
   * There is a robot starting at position (0, 0), the origin, on a 2D plane.
   * Given a sequence of its moves, judge if this robot ends up at (0, 0) after it
   * completes its moves. The move sequence is represented by a string, and the
   * character moves[i] represents its ith move. Valid moves are R (right), L
   * (left), U (up), and D (down). If the robot returns to the origin after it
   * finishes all of its moves, return true. Otherwise, return false. Note: The
   * way that the robot is "facing" is irrelevant. "R" will always make the robot
   * move to the right once, "L" will always make it move left, etc. Also, assume
   * that the magnitude of the robot's movement is the same for each move.
   *
   * Example 1:
   * Input: "UD"
   * Output: true
   * Explanation: The robot moves up once, and then down once. All moves have the
   * same magnitude, so it ended up at the origin where it started. Therefore, we
   * return true.
   *
   * Example 2:
   * Input: "LL"
   * Output: false
   * Explanation: The robot moves left twice. It ends up two "moves" to the left
   * of the origin. We return false because it is not at the origin at the end of
  its moves.
   */
  #include <algorithm>
  #include <array>
  #include <iostream>
  #include <string>
  #include <unordered_map>
  
  using namespace std;
  
  /**
   * Runtime: 12 ms, faster than 97.08% of C++ online submissions for Robot Return
   * to Origin. Memory Usage: 10 MB, less than 97.56% of C++ online submissions
   * for Robot Return to Origin.
   */
  class Solution {
   public:
    bool judgeCircle(string moves) {
      array<int, 4> arr = {0, 0, 0, 0};
      for (auto& move : moves) {
        switch (move) {
          case 'U': {
            arr[0]++;
            break;
          }
          case 'D': {
            arr[1]++;
            break;
          }
          case 'L': {
            arr[2]++;
            break;
          }
          case 'R': {
            arr[3]++;
            break;
          }
        }
      }
      if (arr[0] == arr[1] && arr[2] == arr[3]) {
        return true;
      }
      return false;
    }
  };
  
  /**
   * Runtime: 16 ms, faster than 84.92% of C++ online submissions for Robot Return
   * to Origin. Memory Usage: 10.2 MB, less than 82.93% of C++ online submissions
   * for Robot Return to Origin.
   */
  class Solution {
   public:
    bool judgeCircle(string moves) {
      int vertical = 0, horizontal = 0;
      for (auto& move : moves) {
        switch (move) {
          case 'U': {
            vertical++;
            break;
          }
          case 'D': {
            vertical--;
            break;
          }
          case 'L': {
            horizontal++;
            break;
          }
          case 'R': {
            horizontal--;
            break;
          }
        }
      }
      if (vertical || horizontal) {
        return false;
      }
      return true;
    }
  };
  
  /**
   * Runtime: 24 ms, faster than 13.76% of C++ online submissions for Robot Return
   * to Origin. Memory Usage: 10.1 MB, less than 95.12% of C++ online submissions
   * for Robot Return to Origin.
   */
  class Solution {
   public:
    bool judgeCircle(string moves) {
      unordered_map<char, int> mapOfMoves;
      for (auto& m : moves) {
        mapOfMoves[m]++;
      }
  
      return mapOfMoves['R'] == mapOfMoves['L'] &&
             mapOfMoves['U'] == mapOfMoves['D'];
    }
  };
  