Design Snake Game

import java.util.*;

public class SnakeGame {
    private int width_, height_;
    int[][] food_;
    private int f_idx = 0;
    private Deque<List<Integer>> snake = new ArrayDeque<>();
    Set<Integer> inuse = new HashSet<>();
    private final static Map<String, List<Integer>> dirs = Map.of(
            "U", Arrays.asList(-1, 0),
            "D", Arrays.asList(1, 0),
            "L", Arrays.asList(0, -1),
            "R", Arrays.asList(0, 1)
    );
    int score = 0;
    int rc2idx(int row, int col) {
        return row * width_ + col;
    }

    public SnakeGame(int width, int height, int[][] food) {
        width_ = width;
        height_ = height;
        food_ = food;
        snake.add(Arrays.asList(0, 0));
        inuse.add(0);
    }

    public int move(String direction) {
        List<Integer> head = snake.peekLast();
        int sr = head.get(0) + dirs.get(direction).get(0);
        int sc = head.get(1) + dirs.get(direction).get(1);
        if (sr < 0 || sr >= height_ || sc < 0 || sc >= width_) { return -1; }
        if (f_idx < food_.length && sr == food_[f_idx][0] && sc == food_[f_idx][1]) {
            f_idx++;
            score++;
        } else {
            List<Integer> tail = snake.pollFirst();
            inuse.remove(rc2idx(tail.get(0), tail.get(1)));
        }
        int newHead = rc2idx(sr, sc);
        if (inuse.contains(newHead)) { return -1; }
        snake.add(Arrays.asList(sr, sc));
        inuse.add(newHead);
        return score;
    }
}

/**
 * @param {number} width
 * @param {number} height
 * @param {number[][]} food
 */
var SnakeGame = function(width, height, food) {
  this.width_ = width;
  this.height_ = height;
  this.food_ = food;
  this.snake = [[0, 0]];
  this.inuse = new Set([0]);
  this.dirs = {
    "U": [-1, 0],
    "D": [1, 0],
    "L": [0, -1],
    "R": [0, 1]
  };
  this.score = 0;
  this.rc2idx = (row, col) => {
    return row * this.width_ + col;
  };
};

/**
 * @param {string} direction
 * @return {number}
 */
SnakeGame.prototype.move = function(direction) {
  let sr = this.snake[this.snake.length - 1][0] + this.dirs[direction][0];
  let sc = this.snake[this.snake.length - 1][1] + this.dirs[direction][1];
  if (sr < 0 || sr >= this.height_ || sc < 0 || sc >= this.width_) { return -1; }
  if (this.food_.length > 0 && sr == this.food_[0][0] && sc == this.food_[0][1]) {
    this.food_.shift();
    this.score += 1;
  } else {
    let tail = this.snake.shift();
    this.inuse.delete(this.rc2idx(tail[0], tail[1]));
  }
  let head = this.rc2idx(sr, sc);
  if (this.inuse.has(head)) { return -1; }
  this.snake.push([sr, sc]);
  this.inuse.add(head);
  return this.score;
};

class SnakeGame:

    def __init__(self, width: int, height: int, food: List[List[int]]):
        self.rows = height
        self.cols = width
        self.food = food
        self.snake = [(0, 0)]  # (row, col)
        self.score = 0
        

    def move(self, direction: str) -> int:
        dirs = {
            'U': (-1, 0),
            'D': (1, 0),
            'L': (0, -1),
            'R': (0, 1)
        }
        sr, sc = self.snake[-1][0] + dirs[direction][0], self.snake[-1][1] + dirs[direction][1]
        if sr < 0 or sr >= self.rows or sc < 0 or sc >= self.cols:
            return -1
        if self.food and sr == self.food[0][0] and sc == self.food[0][1]:
            self.food.pop(0)
            self.score += 1
        else:
            self.snake.pop(0)
        if (sr, sc) in self.snake:
            return -1
        self.snake.append((sr, sc))
        return self.score

class SnakeGame

=begin
    :type width: Integer
    :type height: Integer
    :type food: Integer[][]
=end
  def initialize(width, height, food)
    @width_ = width
    @height_ = height
    @food_ = food
    @snake = [[0, 0]]
    @dirs = {
      "U" => [-1, 0],
      "D" => [1, 0],
      "L" => [0, -1],
      "R" => [0, 1]
    }
    @score = 0
  end


=begin
    :type direction: String
    :rtype: Integer
=end
  def move(direction)
    sr, sc = @snake[-1][0] + @dirs[direction][0], @snake[-1][1] + @dirs[direction][1]
    if sr < 0 || sr >= @height_ || sc < 0 || sc >= @width_
      return -1
    end
    if !@food_.empty?  && [sr, sc] == @food_[0]
      @food_.shift
      @score += 1
    else
      @snake.shift
    end
    if @snake.include?([sr, sc])
      return -1
    end
    @snake << [sr, sc]
    @score
  end


end