Detect Capital solution and explanation

def detectCapitalUse(word: str) -> bool:
    capital_count = sum(1 for c in word if c.isupper())
    return (capital_count == len(word) or
            capital_count == 0 or
            (capital_count == 1 and word[0].isupper()))

class Solution {
    public boolean detectCapitalUse(String word) {
        int capCount = 0;
        for (char c : word.toCharArray()) {
            if (Character.isUpperCase(c)) {
                capCount++;
            }
        }
        return capCount == word.length() || capCount == 0 || (capCount == 1 && Character.isUpperCase(word.charAt(0)));
    }
}

#include <cctype>
#include <string>

bool detectCapitalUse(std::string word) {
    int capitalCount = 0;
    int n = word.length();
    for (char ch : word) {
        if (isupper(ch)) capitalCount++;
    }
    return capitalCount == n || capitalCount == 0 || (capitalCount == 1 && isupper(word[0]));
}

var detectCapitalUse = function(word) {
    let capitalCount = 0;
    for (let ch of word) {
        if (ch === ch.toUpperCase()) {
            capitalCount++;
        }
    }
    return capitalCount === word.length || capitalCount === 0 || (capitalCount === 1 && word[0] === word[0].toUpperCase());
};

#include <stdbool.h>
#include <ctype.h>

bool detectCapitalUse(char * word) {
    int n = strlen(word);
    int capitalCount = 0;
    for (int i = 0; i < n; i++) {
        if (isupper(word[i])) capitalCount++;
    }
    if (capitalCount == n) return true;
    if (capitalCount == 0) return true;
    if (capitalCount == 1 && isupper(word[0])) return true;
    return false;
}

public class Solution {
    public bool DetectCapitalUse(string word) {
        int capitalCount = 0;
        foreach (char c in word) {
            if (char.IsUpper(c)) {
                capitalCount++;
            }
        }
        return capitalCount == word.Length || capitalCount == 0 || (capitalCount == 1 && char.IsUpper(word[0]));
    }
}

import re

def detectCapitalUse(word: str) -> bool:
    return bool(re.match(r'^[A-Z]+$|^[a-z]+$|^[A-Z][a-z]*$', word))

import java.util.regex.*;

class Solution {
    public boolean detectCapitalUse(String word) {
        return word.matches("^[A-Z]+$|^[a-z]+$|^[A-Z][a-z]*$");
    }
}

var detectCapitalUse = function(word) {
    return /^[A-Z]+$|^[a-z]+$|^[A-Z][a-z]*$/.test(word);
};

using System.Text.RegularExpressions;

public class Solution {
    public bool DetectCapitalUse(string word) {
        return Regex.IsMatch(word, "^[A-Z]+$|^[a-z]+$|^[A-Z][a-z]*$");
    }
}

function detectCapitalUse(word: string): boolean {
    const cnt = word.split('').reduce((acc, c) => acc + (c === c.toUpperCase() ? 1 : 0), 0);
    return cnt === 0 || cnt === word.length || (cnt === 1 && word[0] === word[0].toUpperCase());
}

func detectCapitalUse(word string) bool {
	cnt := 0
	for _, c := range word {
		if unicode.IsUpper(c) {
			cnt++
		}
	}
	return cnt == 0 || cnt == len(word) || (cnt == 1 && unicode.IsUpper(rune(word[0])))
}