1class Solution {
2    // Maps each keyboard character to its [row, column] position
3    private static final Map<Character, int[]> CHAR_POSITION = new HashMap<>();
4
5    // Static initializer to populate the keyboard layout positions
6    static {
7        String[] keyboardRows = {"qwertyuiop", "asdfghjkl", "zxcvbnm"};
8        for (int row = 0; row < keyboardRows.length; row++) {
9            for (int col = 0; col < keyboardRows[row].length(); col++) {
10                CHAR_POSITION.put(keyboardRows[row].charAt(col), new int[] {row, col});
11            }
12        }
13    }
14
15    public int totalDistance(String s) {
16        // Start from 'a' as the initial finger position (top-left area)
17        char previousChar = 'a';
18        // Accumulates the total Manhattan distance traveled
19        int totalDistance = 0;
20
21        for (char currentChar : s.toCharArray()) {
22            // Retrieve the [row, col] coordinates of the previous and current characters
23            int[] previousPos = CHAR_POSITION.get(previousChar);
24            int[] currentPos = CHAR_POSITION.get(currentChar);
25
26            // Add the Manhattan distance between the two key positions
27            totalDistance += Math.abs(previousPos[0] - currentPos[0])
28                    + Math.abs(previousPos[1] - currentPos[1]);
29
30            // Move the "finger" to the current character for the next iteration
31            previousChar = currentChar;
32        }
33
34        return totalDistance;
35    }
36}
37

1class Solution {
2public:
3    int totalDistance(string s) {
4        // Lazily-initialized, shared mapping from each letter to its (row, column)
5        // position on a standard QWERTY keyboard layout.
6        static unordered_map<char, pair<int, int>> charPosition = [] {
7            unordered_map<char, pair<int, int>> position;
8            vector<string> keyboardRows = {"qwertyuiop", "asdfghjkl", "zxcvbnm"};
9
10            // Iterate over every row and column to record each letter's coordinates.
11            for (int row = 0; row < keyboardRows.size(); ++row) {
12                for (int col = 0; col < keyboardRows[row].size(); ++col) {
13                    charPosition[keyboardRows[row][col]] = {row, col};
14                }
15            }
16            return position;
17        }();
18
19        char prevChar = 'a';  // Finger starts on the 'a' key.
20        int totalDist = 0;    // Accumulated Manhattan distance traveled.
21
22        // For each character, add the Manhattan distance from the previous key.
23        for (char curChar : s) {
24            auto [prevRow, prevCol] = charPosition[prevChar];
25            auto [curRow, curCol] = charPosition[curChar];
26
27            // Manhattan distance: vertical movement + horizontal movement.
28            totalDist += abs(prevRow - curRow) + abs(prevCol - curCol);
29
30            prevChar = curChar;  // Move the finger to the current key.
31        }
32
33        return totalDist;
34    }
35};
36```
37
38A small but important correction worth noting: in the original lambda, the map was populated through the captured-by-name variable `m`, while the lambda returned `m`. In my rewrite I renamed the local variable to `position`, so the lambda body must consistently use `position` for both populating and returning. Here is the corrected lambda portion to ensure consistency:
39
40```cpp
41static unordered_map<char, pair<int, int>> charPosition = [] {
42    unordered_map<char, pair<int, int>> position;
43    vector<string> keyboardRows = {"qwertyuiop", "asdfghjkl", "zxcvbnm"};
44
45    for (int row = 0; row < keyboardRows.size(); ++row) {
46        for (int col = 0; col < keyboardRows[row].size(); ++col) {
47            position[keyboardRows[row][col]] = {row, col};  // populate via 'position'
48        }
49    }
50    return position;
51}();
52

1// Map each letter to its [row, column] position on the keyboard
2const keyPositions: Record<string, [number, number]> = {};
3
4// Layout of a standard QWERTY keyboard, row by row
5const keyboardRows: string[] = ['qwertyuiop', 'asdfghjkl', 'zxcvbnm'];
6
7// Populate the keyPositions map by iterating over each row and each key
8keyboardRows.forEach((row: string, rowIndex: number) => {
9    [...row].forEach((key: string, colIndex: number) => {
10        keyPositions[key] = [rowIndex, colIndex];
11    });
12});
13
14/**
15 * Calculate the total Manhattan distance traveled by a single finger
16 * when typing the given string, starting from the letter 'a'.
17 *
18 * @param s - The string to be typed.
19 * @returns The accumulated distance between consecutive keys.
20 */
21function totalDistance(s: string): number {
22    // The finger always starts at the letter 'a'
23    let previousChar: string = 'a';
24    let answer: number = 0;
25
26    // Move the finger to each character in turn, summing the distances
27    for (const currentChar of s) {
28        const [prevRow, prevCol] = keyPositions[previousChar];
29        const [currRow, currCol] = keyPositions[currentChar];
30
31        // Manhattan distance between the previous and current key
32        answer += Math.abs(prevRow - currRow) + Math.abs(prevCol - currCol);
33
34        // Update the finger's current position
35        previousChar = currentChar;
36    }
37
38    return answer;
39}
40