Typing Speed Test

// WPM & accuracy calculator
function calcWpm(correctChars, elapsedSeconds) {
  const minutes = elapsedSeconds / 60;
  if (minutes === 0) return 0;
  // 1 "word" = 5 characters (industry standard)
  return Math.round((correctChars / 5) / minutes);
}

function calcAccuracy(typed, target) {
  if (typed.length === 0) return 100;
  const correct = [...typed].filter((ch, i) => ch === target[i]).length;
  return Math.round((correct / typed.length) * 100);
}

// Live test example
const passage = "The quick brown fox jumps over the lazy dog";
const typed   = "The quick brwon fox jumps over the lazy dog";
const elapsed = 15; // seconds

const correct = [...typed].filter((ch, i) => ch === passage[i]).length;
console.log(`WPM:      ${calcWpm(correct, elapsed)}`);  // ~35 WPM
console.log(`Accuracy: ${calcAccuracy(typed, passage)}%`); // ~98%

# WPM & accuracy calculator
def calc_wpm(correct_chars: int, elapsed_seconds: float) -> int:
    if elapsed_seconds == 0:
        return 0
    minutes = elapsed_seconds / 60
    return round((correct_chars / 5) / minutes)

def calc_accuracy(typed: str, target: str) -> int:
    if not typed:
        return 100
    correct = sum(t == p for t, p in zip(typed, target))
    return round((correct / len(typed)) * 100)

def evaluate_test(typed: str, target: str, elapsed_seconds: float) -> dict:
    correct_chars = sum(t == p for t, p in zip(typed, target))
    errors = len(typed) - correct_chars
    return {
        "wpm":      calc_wpm(correct_chars, elapsed_seconds),
        "accuracy": calc_accuracy(typed, target),
        "errors":   errors,
        "cpm":      round(correct_chars / (elapsed_seconds / 60)),
    }

# Example
result = evaluate_test("The quick brwon fox", "The quick brown fox", 10)
print(result)  # {'wpm': 35, 'accuracy': 95, 'errors': 1, 'cpm': 174}

interface TypingResult {
  wpm: number;
  accuracy: number;
  errors: number;
  cpm: number;
  correctChars: number;
}

function evaluateTypingTest(
  typed: string,
  target: string,
  elapsedSeconds: number
): TypingResult {
  const correctChars = [...typed].filter((ch, i) => ch === target[i]).length;
  const errors  = typed.length - correctChars;
  const minutes = elapsedSeconds / 60;
  const wpm     = minutes > 0 ? Math.round((correctChars / 5) / minutes) : 0;
  const cpm     = minutes > 0 ? Math.round(correctChars / minutes) : 0;
  const accuracy = typed.length > 0
    ? Math.round((correctChars / typed.length) * 100) : 100;

  return { wpm, accuracy, errors, cpm, correctChars };
}

// Usage
const result = evaluateTypingTest(
  "The quick brwon fox",
  "The quick brown fox",
  10
);
console.log(result); // { wpm: 35, accuracy: 95, errors: 1, cpm: 174, correctChars: 18 }

package main

import (
    "fmt"
    "math"
)

type TypingResult struct {
    WPM      int
    Accuracy int
    Errors   int
    CPM      int
}

func EvaluateTest(typed, target string, elapsedSeconds float64) TypingResult {
    typedRunes  := []rune(typed)
    targetRunes := []rune(target)
    correct := 0
    for i, ch := range typedRunes {
        if i < len(targetRunes) && ch == targetRunes[i] {
            correct++
        }
    }
    errors  := len(typedRunes) - correct
    minutes := elapsedSeconds / 60
    wpm, cpm, accuracy := 0, 0, 100
    if minutes > 0 {
        wpm = int(math.Round(float64(correct/5) / minutes))
        cpm = int(math.Round(float64(correct) / minutes))
    }
    if len(typedRunes) > 0 {
        accuracy = int(math.Round(float64(correct) / float64(len(typedRunes)) * 100))
    }
    return TypingResult{WPM: wpm, Accuracy: accuracy, Errors: errors, CPM: cpm}
}

func main() {
    r := EvaluateTest("The quick brwon fox", "The quick brown fox", 10)
    fmt.Printf("%+v
", r) // {WPM:35 Accuracy:95 Errors:1 CPM:174}
}

#[derive(Debug)]
struct TypingResult {
    wpm: u32,
    accuracy: u32,
    errors: usize,
    cpm: u32,
}

fn evaluate_test(typed: &str, target: &str, elapsed_seconds: f64) -> TypingResult {
    let correct = typed
        .chars()
        .zip(target.chars())
        .filter(|(t, p)| t == p)
        .count();
    let errors  = typed.chars().count().saturating_sub(correct);
    let minutes = elapsed_seconds / 60.0;
    let (wpm, cpm) = if minutes > 0.0 {
        (
            ((correct as f64 / 5.0) / minutes).round() as u32,
            (correct as f64 / minutes).round() as u32,
        )
    } else {
        (0, 0)
    };
    let accuracy = if !typed.is_empty() {
        ((correct as f64 / typed.chars().count() as f64) * 100.0).round() as u32
    } else { 100 };

    TypingResult { wpm, accuracy, errors, cpm }
}

fn main() {
    let r = evaluate_test("The quick brwon fox", "The quick brown fox", 10.0);
    println!("{:?}", r); // TypingResult { wpm: 35, accuracy: 95, errors: 1, cpm: 174 }
}