Single-Row Keyboard

class Solution {
public:
    int calculateTime(string keyboard, string word) {
        vector<int> positionMap(26, -1);

        // Mapping character to its position on keyboard
        for (int idx = 0; idx < keyboard.size(); idx++)
            positionMap[keyboard[idx] - 'a'] = idx;

        // Start from the first position
        int lastPosition = 0;
        int totalTime = 0;

        // Calculate the time to type each character in word
        for (char &ch : word) {
            totalTime += abs(lastPosition - positionMap[ch - 'a']);
            lastPosition = positionMap[ch - 'a'];
        }
        return totalTime;
    }
};

The given C++ code defines a solution for finding the minimum time required to type a word on a theoretical single-row keyboard where each character's position is unique. Calculate the time by simulating the movement of a finger to type each character of the word based on its position on the keyboard. Here's how the solution works:

• First, create a mapping of each character to its respective position on the keyboard. This is done using a vector positionMap where the index represents the character and the value at that index represents the position of that character on the keyboard.

• Initialize lastPosition to 0 to represent the starting point of the finger at the beginning of the keyboard.

• Initialize totalTime to 0 to accumulate the total time spent moving from character to character.

For each character in the word:

1. Calculate the difference between the last position of the finger and the new character's position to get the movement cost.
2. Update lastPosition to the current character's position.
3. Accumulate this movement cost to totalTime.

Finally, the function returns totalTime, which represents the total amount of time taken to type the entire word on the keyboard.

class Solution {
    public int computeTypingTime(String layout, String text) {
        int[] position = new int[26];

        // Assign each character its position from layout.
        for (int i = 0; i < layout.length(); i++)
            position[layout.charAt(i) - 'a'] = i;

        // Initial position.
        int previous = 0;
        int totalTime = 0;

        // Calculate total typing duration.
        for (char c : text.toCharArray()) {
            // Increment totalTime by movement distance.
            totalTime += Math.abs(previous - position[c - 'a']);

            // Current becomes the new previous.
            previous = position[c - 'a'];
        }
        return totalTime;
    }
}

This solution addresses the problem of calculating the typing time on a single-row keyboard where each character's position is defined by a given layout. Written in Java, the approach involves mapping each character to its position on this custom keyboard layout and then calculating the time based on the movements required to type a given text.

• Initialize an array to store the position of each letter in the alphabet based on the custom keyboard layout.
• Loop through the layout string and assign each character a position index.
• Calculate the total time it takes to type the text:
  • Begin at the start of the layout (initial position is 0).
  • For each character in the text, compute the distance from the current position to the character's position in the layout. The absolute difference in positions translates directly to typing time.
  • Move the current position to the last character typed.

The function returns the accumulated total time required to type all characters in the input text according to the specified keyboard layout. This solution effectively measures the efficiency of typing based on finger travel distance on a uniquely defined keyboard.