Introduction

I can type at a moderate pace, using the QWERTY keyboard layout. But if a word like yellowwooddoor has a ton of repeated letters, it takes a bit longer to type it. Even worse is when a word like "jump" has the same finger used for multiple different consecutive letters.

Here's how long it takes me to type letters on each finger (very unscientifically measured):

Columns are Finger name, keystrokes/second, seconds/keystroke, and the keys used by each finger

Typing same letter twice: 
L Pinky 5.2 0.1923076923 1qaz
L Ring 5 0.2 2wsx
L Mid 5.3 0.1886792453 3edc
L Index 5.5 0.1818181818 4rfv5tgb
R Thumb 6.5 0.1538461538 [space]
R Index 6.9 0.1449275362 6yhn7ujm
R Mid 6.3 0.1587301587 8ik,
R Ring 6.2 0.1612903226 9ol.
R Pinky 6.1 0.1639344262 0p;'

Typing different letter on same finger: 
L Pinky 4.6 0.2173913043
L Ring 4.6 0.2173913043
L Mid 4.5 0.2222222222
L Index 5.3 0.1886792453
R Index 5.4 0.1851851852
R Mid 5.1 0.1960784314
R Ring 5.2 0.1923076923
R Pinky 5.2 0.1923076923

Same data in CSV format.

It takes

.75 * (first_finger_same_letter_time + second_finger_same_letter_time) / 2

time to switch between two fingers.

Challenge

Given a string as input, how long does it take to type it?

• The "timer" starts the moment the first key is pressed and ends when the last key is pressed. You are just counting the time between keypresses.


• This is code-golf. Shortest answer in bytes wins.


• Submission can be either a complete program or function.


• Input and output any way you want it, stdin/out, function params, file, doesn't matter.


• Output should be accurate to at least 3 decimal places (+/- 0.001 for rounding error is fine). Leading 0. for numbers under 1 and trailing newline optional.


• Input will be a string that contains (lowercase) a-z, 0-9, space, semicolon, comma, period, and apostrophe.


• I always type spaces with my right thumb.


• I use the normal touch typing fingers (you can also look at the above table for finger-key mappings).


• Reference code used to generate test cases

Test cases

(empty string or any one-character string) - 0.000

aa - 0.192

fff - 0.364

fj - 0.123

the quick brown fox jumped over the lazy dog - 5.795

yellowwooddoor - 1.983

orangewooddoor - 1.841

jump on it, jump on it - 2.748

type on it, type on it - 2.549

abcdefghijklmnopqrstuvwxyz01234567890 ;,.' - 5.746

ok, this may not be the most accurate but it's in the ballpark, maybe within 30 percent or so. - 12.138

JavaScript (Node.js), 180 bytes

s=>(B=Buffer)(s).map(p=c=>(b='23841410645532207643205431765001333746443'[c*45%91%73%41]*2,t+=1/p?p-b?3/8*(g(b)+g(p)):g(b|c!=s):0,p=b,s=c),t=0,g=x=>10/B('4.2.5-75E6?3>4=4AA')[x])&&t

Try it online!

How?

Storing delays

The helper function $g$ takes an integer $0le x le17$ and returns a delay in seconds.

g = x => 10 / Buffer('4.2.5-75E6?3>4=4AA')[x]

The input $x$ is expected to be either:

• twice the bin number to get the delay for the same letter


• twice the bin number + 1 to get the delay for different letters

What is actually stored in the string '4.2.5-75E6?3>4=4AA' is the number of keystrokes per second multiplied by $10$ and converted to ASCII. Conveniently, all resulting characters are printable.

For instance, $5.2$ is stored as chr(52) which is '4'.

Converting a character to a key bin

We use the following hash function to convert an ASCII code $c$ to an index into a lookup table containing the bin numbers in $[0..8]$:

$$i = (((ctimes 45) bmod 91)bmod 73)bmod 41$$

Main loop

The total time $t$ is updated with:

t += // add to t:
 1 / p ? // if p is numeric:
 p - b ? // if p is not equal to b:
 3 / 8 * (g(b) + g(p)) // 0.75 * (g(b) + g(p)) / 2
 : // else:
 g(b | c != s) // g(b) if c == s or g(b + 1) otherwise
 : // else (first iteration):
 0 // leave t unchanged

where $p$ is the previous bin and $s$ is the previous character.

Jelly, 78 bytes

“bk¶ŀqṣṁq*E’b25+45s2
Øq;"““;“,.'”Zṙ-ØD;"s2ẎW$€3,4¦ẎœiⱮQḢ€ị¢QƑịZƊQ3.75⁵Ḋ?÷$SµƝS

Try it online!

How?

“...’b25+45s2 - Link 1, keystrokes per 10 seconds: no arguments
“...’ - base 250 integer = 379310849477441257135820
 b25 - to base 25 = [16,7,7,1,5,1,8,0,10,8,24,9,18,6,17,7,20]
 +45 - add 45 = [61,52,52,46,50,46,53,45,55,53,69,54,63,51,62,52,65]
 s2 - split into twos
 - = [[61,52],[52,46],[50,46],[53,45],[55,53],[69,54],[63,51],[62,52],[65]]
 - For: 0... 1... 2... 3... 4... 6... 8... 9... space

Øq;"““;“,.'”Zṙ-ØD;"s2ẎW$€3,4¦ẎœiⱮQḢ€ị¢QƑịZƊQ3.75⁵Ḋ?÷$SµƝS - Main Link: list of characters
 µƝ - for each neighbouring pair:
Øq - qwerty = ["qwertyuiop","asdfghjkl","zxcvbnm"]
 ““;“,.'” - list of lists = ["",";",",.'"]
 " - zip with:
 ; - concatenate = ["qwertyuiop","asdfghjkl;","zxcvbnm,.'"]
 Z - transpose = ["qaz","wsx","edc","rfv","tgb","yhn","ujm","ik,","ol.","p;'"]
 ṙ- - rotate left -1 = ["p;'","qaz","wsx","edc","rfv","tgb","yhn","ujm","ik,","ol."]
 ØD - digits = "0123456789"
 " - zip with:
 ; - concatenate = ["0p;'","1qaz","2wsx","3edc","4rfv","5tgb","6yhn","7ujm","8ik,","9ol."]
 s2 - split into twos = [["0p;'","1qaz"],["2wsx","3edc"],["4rfv","5tgb"],["6yhn","7ujm"],["8ik,","9ol."]]
 ¦ - sparse application...
 3,4 - ...to indices: [3,4]
 $€ - ...do: last two links as a monad for each:
 Ẏ - tighten
 W - wrap in a list = [["0p;'","1qaz"],["2wsx","3edc"],["4rfv5tgb"],["6yhn7ujm"],["8ik,","9ol."]]
 Ẏ - tighten = ["0p;'","1qaz","2wsx","3edc","4rfv5tgb","6yhn7ujm","8ik,","9ol."]
 Q - de-duplicate (the neighbouring letters)
 Ɱ - map with:
 œi - multi-dimensional index-into e.g. "fj" -> [[5,3],[6,7]]
 - (note <space> is not there so yields an empty list)
 Ḣ€ - head of each -> [5,6]
 - (...and the head of an empty list is 0)
 ¢ - call the last Link (1) as a nilad
 ị - index-into -> [[55,53],[69,54]]
 - (...and 0 indexes into the rightmost entry)
 Ɗ - last three links as a monad:
 Ƒ - invariant under?:
 Q - de-duplicate (1 if so, else 0)
 Z - transpose -> [[55,69],[53,54]]
 ị - index-into -> [55,69]
 Q - de-duplicate -> [55,69]
 $ - last two links as a monad:
 ? - if...
 Ḋ - ...condition: dequeue
 3.75 - ...then: 3.75
 ⁵ - ...else: 10 -> 3.75
 ÷ - divide -> [0.06818181818181818,0.05434782608695652]
 S - sum -> 0.12252964426877469
 S - sum