#709

Easy

auto_awesomeString-driven solution strategy

LeetCode Problem Workspace

To Lower Case

The "To Lower Case" problem asks you to convert all uppercase letters in a string to lowercase.

Problem Statement

Given a string s, the task is to return a new string where every uppercase letter in s has been replaced by its corresponding lowercase letter. You need to process each character of the string individually and modify the string accordingly.

For example, when given the input "Hello", you should return "hello". The problem emphasizes understanding string manipulation and processing at the character level, even when libraries or built-in functions might provide shortcuts.

Examples

Example 1

Input: s = "Hello"

Output: "hello"

Example details omitted.

Example 2

Input: s = "here"

Output: "here"

Example details omitted.

Example 3

Input: s = "LOVELY"

Output: "lovely"

Example details omitted.

Constraints

1 <= s.length <= 100
s consists of printable ASCII characters.

Solution Approach

Iterate and Convert

The simplest approach is to iterate through each character of the string, checking if it's an uppercase letter. If so, convert it to lowercase manually using a character transformation, and build the new string incrementally.

Built-in Method

Many languages provide a direct string method to convert all uppercase letters to lowercase (e.g., toLowerCase() in JavaScript or str.lower() in Python). This is often the most efficient approach, leveraging optimized native implementations.

Manual Character Mapping

In cases where built-in methods are not available or allowed, you can manually adjust the character codes. This involves using the ASCII values of characters, converting uppercase letters (65-90) to lowercase (97-122) by adding a fixed offset, and reconstructing the string.

Complexity Analysis

Metric	Value
Time	Depends on the final approach
Space	Depends on the final approach

The time complexity of this problem depends on the approach used. If iterating and manually converting characters, the complexity is O(n), where n is the length of the string. Using a built-in method is typically optimized to achieve O(n) in practice. Space complexity is O(n) in both cases, as a new string must be created to store the transformed result.

What Interviewers Usually Probe

Candidates should demonstrate a solid understanding of string manipulation and be able to articulate trade-offs in terms of efficiency and readability.
The problem tests a candidate's ability to think about edge cases, like handling strings that contain no uppercase characters.
The interviewer will look for clarity in how the candidate justifies their choice of approach, particularly regarding the use of built-in methods vs. manual implementations.

Common Pitfalls or Variants

Common pitfalls

Candidates may use the built-in function without understanding its internal workings, missing an opportunity to demonstrate algorithmic thinking.
Forgetting to handle cases where no uppercase letters exist in the string can lead to unnecessary processing or incorrect assumptions.
Failing to optimize for space complexity by repeatedly modifying the string (in languages that don't handle immutability) can lead to inefficient solutions.

Follow-up variants

Convert a string to uppercase instead of lowercase.
Handle case insensitivity by converting both uppercase and lowercase characters to a common case.
Process a string in place to reduce space complexity, if mutable strings are allowed.

FAQ

What is the best approach to solve the "To Lower Case" problem?

The best approach is often to use a built-in method like toLowerCase(). However, if not available, manually processing characters one-by-one is a viable alternative.

Does the "To Lower Case" problem require using built-in string methods?

No, but using built-in methods like toLowerCase() is the most efficient approach. The problem can also be solved by manually iterating through the string.

How do I optimize the "To Lower Case" solution for large strings?

You should ensure a single pass over the string with an O(n) time complexity. Avoid unnecessary string modifications or copies to save space.

Can I solve the "To Lower Case" problem without converting the string to a new one?

Yes, in languages with mutable strings, you can modify the string in place, but in most languages, strings are immutable, requiring a new one to be created.

Are there any edge cases for the "To Lower Case" problem?

Yes, edge cases include strings with no uppercase letters or empty strings. Both should return the string unchanged or an empty string.

terminal

Solution

Solution 1

#### Python3

1

2

3

class Solution:
    def toLowerCase(self, s: str) -> str:
        return "".join([chr(ord(c) | 32) if c.isupper() else c for c in s])

Solution 2

#### TypeScript

1

2

3

class Solution:
    def toLowerCase(self, s: str) -> str:
        return "".join([chr(ord(c) | 32) if c.isupper() else c for c in s])

Continue Practicing

#712 minimum ascii delete sum for two strings #720 longest word in dictionary #721 accounts merge