# Leetcode – Detect Capital Solution in Python

## Introduction

The Detect Capital problem is an intriguing challenge on Leetcode, focusing on string manipulation and character case identification. It’s a great problem for honing one’s skills in handling strings and understanding various Python functionalities. In this comprehensive article, we will dissect the Detect Capital problem, understand its constraints, and explore various approaches to solve it using Python.

The Detect Capital problem on Leetcode is described as follows:

Given a word, you need to judge whether the usage of capitals in it is right or not.
We define the usage of capitals in a word to be right when one of the following cases holds.

1. All letters in this word are capitals (e.g., “USA”).
2. All letters in this word are not capitals, except the first letter which is capital (e.g., “Google”).
3. There are no capital letters at all (e.g., “leetcode”).

Return True if the word’s usage of capitals is right, otherwise return False.

For example:

Input: "USA"
Output: True

Input: "FlaG"
Output: False

## Approach 1: Python Built-in Functions

Python provides built-in functions such as isupper() and istitle() which can be used to solve this problem in a concise manner.

Here’s a Python code for this approach.

def detectCapitalUse(word):
# Check if all characters are uppercase or if it's in title case or if all characters are lowercase
return word.isupper() or word.istitle() or word.islower()

This approach is highly efficient with a time complexity of O(n) where n is the length of the word. It leverages Python’s built-in string functions to make the code simple and elegant.

## Approach 2: Iterative Solution

Another approach to solving this problem is to iterate through the characters of the word and keep track of the number of capital letters. This approach gives us a better understanding of the logic involved.

Here’s the Python code for this approach.

def detectCapitalUse(word):
# Count the number of capital letters in the word
capital_count = sum(1 for c in word if c.isupper())

# Check the three cases
return (capital_count == 0) or \
(capital_count == 1 and word.isupper()) or \
(capital_count == len(word))

This approach also has a time complexity of O(n), and while it’s not as concise as the first approach, it provides a more explicit logic flow.

## Approach 3: Regular Expressions

We can also solve this problem using regular expressions. Regular expressions are a powerful tool for pattern matching in strings.

Here’s how we can use a regular expression to solve this problem.

import re

def detectCapitalUse(word):
# The pattern matches the three cases: all uppercase, title case, all lowercase
pattern = re.compile(r'^([A-Z]*|[A-Z]?[a-z]*)\$')
return bool(pattern.match(word))

This approach makes use of the re module in Python. It’s also efficient, but regular expressions can sometimes be harder to understand for those not familiar with them.

## Conclusion

In this extensive article, we examined the Detect Capital problem on Leetcode and explored three distinct approaches to solving it using Python. We utilized Python’s built-in functions, implemented an iterative solution, and experimented with regular expressions.