Skip to content

2194. Cells in a Range on an Excel Sheet

SourceWeekly Contest 283 Q1DifficultyEasyRating1253

Description

A cell (r, c) of an excel sheet is represented as a string "<col><row>" where:

  • <col> denotes the column number c of the cell. It is represented by alphabetical letters.
    • For example, the 1st column is denoted by 'A', the 2nd by 'B', the 3rd by 'C', and so on.
  • <row> is the row number r of the cell. The rth row is represented by the integer r.

You are given a string s in the format "<col1><row1>:<col2><row2>", where <col1> represents the column c1, <row1> represents the row r1, <col2> represents the column c2, and <row2> represents the row r2, such that r1 <= r2 and c1 <= c2.

Return the list of cells (x, y) such that r1 <= x <= r2 and c1 <= y <= c2. The cells should be represented as strings in the format mentioned above and be sorted in non-decreasing order first by columns and then by rows.

 

Example 1:

Input: s = "K1:L2"
Output: ["K1","K2","L1","L2"]
Explanation:
The above diagram shows the cells which should be present in the list.
The red arrows denote the order in which the cells should be presented.

Example 2:

Input: s = "A1:F1"
Output: ["A1","B1","C1","D1","E1","F1"]
Explanation:
The above diagram shows the cells which should be present in the list.
The red arrow denotes the order in which the cells should be presented.

 

Constraints:

  • s.length == 5
  • 'A' <= s[0] <= s[3] <= 'Z'
  • '1' <= s[1] <= s[4] <= '9'
  • s consists of uppercase English letters, digits and ':'.

Solutions

Solution 1: Simulation

Thinking

A range such as A1:F2 should list cells column-major, then by row. Both spans are tiny, so a double loop is enough.

Iterate column characters in the outer loop and row numbers in the inner loop, concatenating each cell.

The start and end columns are the first and last letters of \(s\); the rows are the two digits.

We directly traverse all the cells within the range and add them to the answer array.

The time complexity is \(O(m \times n)\), and the space complexity is \(O(m \times n)\), where \(m\) and \(n\) are the range of rows and columns, respectively.

1
2
3
4
5
6
7
class Solution:
    def cellsInRange(self, s: str) -> List[str]:
        return [
            chr(i) + str(j)
            for i in range(ord(s[0]), ord(s[-2]) + 1)
            for j in range(int(s[1]), int(s[-1]) + 1)
        ]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
class Solution {
    public List<String> cellsInRange(String s) {
        List<String> ans = new ArrayList<>();
        for (char i = s.charAt(0); i <= s.charAt(3); ++i) {
            for (char j = s.charAt(1); j <= s.charAt(4); ++j) {
                ans.add(i + "" + j);
            }
        }
        return ans;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
class Solution {
public:
    vector<string> cellsInRange(string s) {
        vector<string> ans;
        for (char i = s[0]; i <= s[3]; ++i) {
            for (char j = s[1]; j <= s[4]; ++j) {
                ans.push_back({i, j});
            }
        }
        return ans;
    }
};

1
2
3
4
5
6
7
8
func cellsInRange(s string) (ans []string) {
    for i := s[0]; i <= s[3]; i++ {
        for j := s[1]; j <= s[4]; j++ {
            ans = append(ans, string(i)+string(j))
        }
    }
    return
}

1
2
3
4
5
6
7
8
9
function cellsInRange(s: string): string[] {
    const ans: string[] = [];
    for (let i = s.charCodeAt(0); i <= s.charCodeAt(3); ++i) {
        for (let j = s.charCodeAt(1); j <= s.charCodeAt(4); ++j) {
            ans.push(String.fromCharCode(i) + String.fromCharCode(j));
        }
    }
    return ans;
}

Comments