Design Spreadsheet

• Initialize a HashMap<String, Integer> cells to store cell values. * In setCell(cell, value), call cells.put(cell, value). * In resetCell(cell), call cells.remove(cell) to revert the cell's value to the default of 0. * In getValue(formula): * Parse the formula "=X+Y" to extract terms X and Y. * Create a helper function evaluate(term): * If term starts with a letter, it's a cell reference. Return cells.getOrDefault(term, 0). * Otherwise, it's a number. Return Integer.parseInt(term). * Return the sum of the evaluated terms X and Y.

This approach models the spreadsheet as a sparse grid, storing only the cells that have been assigned a value. A java.util.HashMap<String, Integer> is the core data structure. * Data Storage: A HashMap<String, Integer> cells maps a cell's string identifier (e.g., "A1") to its integer value. * Initialization: The Spreadsheet constructor is very fast, as it only needs to create a new empty HashMap. * setCell: To set a cell's value, we simply add or update an entry in the map: cells.put(cell, value). * resetCell: To reset a cell, we remove its entry from the map: cells.remove(cell). This is efficient as subsequent lookups for this cell will default to 0. * getValue: This method involves parsing the formula string. A helper function, parseTerm, determines if a term is a number or a cell reference. For cell references, it queries the map using cells.getOrDefault(term, 0), which conveniently returns 0 if the cell hasn't been set. Here is a sample implementation in Java:

1java  import java.util.HashMap;  import java.util.Map;  class Spreadsheet {      private Map<String, Integer> cells;      private int rows;      private final int cols = 26;      public Spreadsheet(int rows) {          this.rows = rows;          this.cells = new HashMap<>();      }      public void setCell(String cell, int value) {          cells.put(cell, value);      }      public void resetCell(String cell) {          cells.remove(cell);      }      private int parseTerm(String term) {          if (Character.isLetter(term.charAt(0))) {              return cells.getOrDefault(term, 0);          } else {              return Integer.parseInt(term);          }      }      public int getValue(String formula) {          String[] parts = formula.substring(1).split("\\+");          String term1Str = parts[0];          String term2Str = parts[1];          int val1 = parseTerm(term1Str);          int val2 = parseTerm(term2Str);          return val1 + val2;      }  }  

• Initialize an int[][] grid of size rows x 26. * Create a helper function parseCellToCoords(cell): * col = cell.charAt(0) - 'A'. * row = Integer.parseInt(cell.substring(1)) - 1. * Return [row, col]. * In setCell(cell, value): * Get [row, col] from parseCellToCoords(cell). * Set grid[row][col] = value. * In resetCell(cell): * Get [row, col] from parseCellToCoords(cell). * Set grid[row][col] = 0. * In getValue(formula): * Parse the formula to get terms X and Y. * Create a helper evaluate(term): * If term is a cell reference, get [row, col] from parseCellToCoords(term) and return grid[row][col]. * Otherwise, parse it as an integer. * Return the sum of the evaluated terms.

This approach uses a 2D array, int[][] grid, which directly mirrors the structure of the spreadsheet. This allows for constant-time access to any cell once its reference is parsed into row and column indices. * Data Storage: An int[][] grid of size rows x 26 is used. grid[r][c] stores the value of the cell at row r+1 and column c. * Initialization: The Spreadsheet constructor allocates the rows x 26 array. Java automatically initializes all elements to 0. * Cell Parsing: A crucial helper function, parseCellToCoords(String cell), is needed to translate string references like "B10" into array indices [9, 1]. This is done by converting the character 'B' to a column index ('B' - 'A' = 1) and the string "10" to a 0-indexed row (10 - 1 = 9). * setCell / resetCell: These methods first call parseCellToCoords to get the (row, col) indices and then directly access grid[row][col] to set the value or reset it to 0. * getValue: Similar to the HashMap approach, this method parses the formula. When a term is identified as a cell reference, parseCellToCoords is used to find its indices, and the value is retrieved directly from the grid. Here is a sample implementation in Java:

1java  class Spreadsheet {      private int[][] grid;      private int rows;      private final int cols = 26;      public Spreadsheet(int rows) {          this.rows = rows;          this.grid = new int[rows][this.cols];      }      private int[] parseCellToCoords(String cell) {          int col = cell.charAt(0) - 'A';          int row = Integer.parseInt(cell.substring(1)) - 1;          return new int[]{row, col};      }      public void setCell(String cell, int value) {          int[] coords = parseCellToCoords(cell);          grid[coords[0]][coords[1]] = value;      }      public void resetCell(String cell) {          int[] coords = parseCellToCoords(cell);          grid[coords[0]][coords[1]] = 0;      }      private int parseTerm(String term) {          if (Character.isLetter(term.charAt(0))) {              int[] coords = parseCellToCoords(term);              return grid[coords[0]][coords[1]];          } else {              return Integer.parseInt(term);          }      }      public int getValue(String formula) {          String[] parts = formula.substring(1).split("\\+");          String term1Str = parts[0];          String term2Str = parts[1];          int val1 = parseTerm(term1Str);          int val2 = parseTerm(term2Str);          return val1 + val2;      }  }