## 1165. Single-Row Keyboard

There is a special keyboard with all keys in a single row.

Given a string `keyboard` of length 26 indicating the layout of the keyboard (indexed from 0 to 25), initially your finger is at index 0. To type a character, you have to move your finger to the index of the desired character. The time taken to move your finger from index `i` to index `j` is `|i - j|`.

You want to type a string `word`. Write a function to calculate how much time it takes to type it with one finger.

Example 1:

```Input: keyboard = "abcdefghijklmnopqrstuvwxyz", word = "cba"
Output: 4
Explanation: The index moves from 0 to 2 to write 'c' then to 1 to write 'b' then to 0 again to write 'a'.
Total time = 2 + 1 + 1 = 4.
```

Example 2:

```Input: keyboard = "pqrstuvwxyzabcdefghijklmno", word = "leetcode"
Output: 73
```

Constraints:

• `keyboard.length == 26`
• `keyboard` contains each English lowercase letter exactly once in some order.
• `1 <= word.length <= 10^4`
• `word[i]` is an English lowercase letter.

## Rust Solution

``````struct Solution;

impl Solution {
fn calculate_time(keyboard: String, word: String) -> i32 {
let mut indexes: Vec<i32> = vec![0; 26];
for (i, b) in keyboard.bytes().enumerate() {
indexes[(b - b'a') as usize] = i as i32;
}
let mut prev = 0;
let mut sum = 0;
for b in word.bytes() {
let index = indexes[(b - b'a') as usize];
sum += (index - prev).abs();
prev = index;
}
sum
}
}

#[test]
fn test() {
let keyboard = "abcdefghijklmnopqrstuvwxyz".to_string();
let word = "cba".to_string();
assert_eq!(Solution::calculate_time(keyboard, word), 4);
let keyboard = "pqrstuvwxyzabcdefghijklmno".to_string();
let word = "leetcode".to_string();
assert_eq!(Solution::calculate_time(keyboard, word), 73);
}
``````

Having problems with this solution? Click here to submit an issue on github.