What is the time complexity of To Lower Case?

The optimal solution has a time complexity of O(n).

What data structures are used to solve To Lower Case?

This problem uses String. Understanding these concepts is essential for solving this Easy problem efficiently.

What are the key insights for solving To Lower Case?

Insight 1: Understanding ASCII representation of characters is crucial. Uppercase and lowercase letters have a consistent difference in their ASCII values. Insight 2: In languages like Python and Java, built-in string functions (`lower()` and `toLowerCase()`, respectively) can directly achieve the desired conversion.

Which companies ask LeetCode 709. To Lower Case in interviews?

This problem is frequently asked at Infosys.

JavaScript is required for the full interactive experience. However, all content is accessible without JavaScript.

To Lower Case - LeetCode 709 Solution

Q: How to solve To Lower Case?

The solutions approach varies depending on the programming language. Python and Java leverage built-in string functions for direct conversion. C and C++ demonstrate manual iteration through the string, checking if each character is an uppercase letter. If it is, it calculates the corresponding lowercase letter by adding the difference between 'a' and 'A' (which is 32) to the character's ASCII value. The C solution modifies the string in place. The C++ solution does the same, making use of a reference to the string's characters.

To Lower Case - Complete Solution Guide

To Lower Case is LeetCode problem 709, a Easy level challenge. This complete guide provides step-by-step explanations, multiple solution approaches, and optimized code in python3, java, cpp, c.

Problem Statement

Given a string s , return the string after replacing every uppercase letter with the same lowercase letter . Example 1: Input: s = "Hello" Output: "hello" Example 2: Input: s = "here" Output: "here" Example 3: Input: s = "LOVELY" Output: "lovely" Constraints: 1 <= s.length <= 100 s consists of printable ASCII characters.

Detailed Explanation

The problem asks us to convert a given string `s` to lowercase. This means every uppercase letter in the string should be replaced with its corresponding lowercase letter, while all other characters (lowercase letters, numbers, symbols) should remain unchanged. The input is a string `s` consisting of printable ASCII characters, and the output is the modified string with all uppercase letters converted to lowercase. The length of the input string is between 1 and 100 characters inclusive.

Solution Approach

The solutions approach varies depending on the programming language. Python and Java leverage built-in string functions for direct conversion. C and C++ demonstrate manual iteration through the string, checking if each character is an uppercase letter. If it is, it calculates the corresponding lowercase letter by adding the difference between 'a' and 'A' (which is 32) to the character's ASCII value. The C solution modifies the string in place. The C++ solution does the same, making use of a reference to the string's characters.

Step-by-Step Algorithm

Step 1: Iterate through each character of the input string `s`.
Step 2: For each character, check if it falls within the ASCII range of uppercase letters ('A' to 'Z').
Step 3: If the character is an uppercase letter, add 32 (the difference between 'a' and 'A') to its ASCII value to convert it to its lowercase equivalent. This is equivalent to s[i] = s[i] - 'A' + 'a' in C.
Step 4: If the character is not an uppercase letter, leave it unchanged.
Step 5: Return the modified string.

Key Insights

Insight 1: Understanding ASCII representation of characters is crucial. Uppercase and lowercase letters have a consistent difference in their ASCII values.
Insight 2: In languages like Python and Java, built-in string functions (`lower()` and `toLowerCase()`, respectively) can directly achieve the desired conversion.
Insight 3: When implementing the conversion manually (as in the C/C++ solutions), efficient in-place modification of the string is preferable to creating a new string if possible to optimize space complexity.

Complexity Analysis

Time Complexity: O(n)

Space Complexity: O(n)

Topics

This problem involves: String.

Companies

Asked at: Infosys.

To Lower Case | LeetCode 709

Easy

String

Time: O(n)Space: O(n)

Solution Code

Available in:

class Solution {
    public String toLowerCase(String s) {
        return s.toLowerCase();
    }
}

View Full Solution on GitHubGitHub Solution View on LeetCodeLeetCode

Problem Info

Description

Problem 709: To Lower Case - Detailed explanation and solution approaches.

Topics

String

Companies

Infosys

Stats

Difficulty:Easy

Languages:4

Companies:1

Problem #:709

Problem Explanation

💡

Think Before You Code

🤔 Ask Yourself

→What is the input? What output do I need?
→Can I solve a smaller version of this problem first?
→What patterns have I seen in similar problems?

✏️ Try This First

Before looking at the solution, try to solve it on paper with a simple example!

🚀 Try on LeetCode

Solution Approach

📋

Step-by-Step Solution

5 steps

1
Step 1: Iterate through each character of the input string `s`.
2
Step 2: For each character, check if it falls within the ASCII range of uppercase letters ('A' to 'Z').
3
Step 3: If the character is an uppercase letter, add 32 (the difference between 'a' and 'A') to its ASCII value to convert it to its lowercase equivalent. This is equivalent to s[i] = s[i] - 'A' + 'a' in C.
4
Step 4: If the character is not an uppercase letter, leave it unchanged.
5
Step 5: Return the modified string.

💡

Pro Tip for Students

Try tracing through each step with a small example on paper before coding. Understanding "why" each step happens is more important than memorizing the code!

⚡

Complexity Analysis

⏱️

Time Complexity

O(n)

👍 Linear - Good! Visits each element once.

💾

Space Complexity

O(n)

📦 Linear space - Memory grows with input size.

📝

Why?

The time complexity is linear because the algorithm examines each character of the string. The space complexity depends on whether a new string is created or the original string is modified in place. Python and Java `lower()` functions typically return a new string, hence O(n) space.

📖New to Big O? Click to learn more

Big O Notation - Quick Guide

O(1)Best - Instant

O(log n)Excellent - Binary Search

O(n)Good - One loop

O(n log n)OK - Sorting

O(n²)Slow - Nested loops

O(2ⁿ)Very Slow - Recursion

Alternative Approaches

Using StringBuilder (Java)

Instead of using String.toLowerCase(), you could iterate through the string and manually convert each character to lowercase using a StringBuilder for mutable string manipulation.

Time: O(n)Space: O(n)

Trade-offs: Using StringBuilder provides more control over the string manipulation process, but `toLowerCase()` is usually more concise and efficient for simple lowercase conversion.

✨

Key Insights

1Insight 1: Understanding ASCII representation of characters is crucial. Uppercase and lowercase letters have a consistent difference in their ASCII values.
2Insight 2: In languages like Python and Java, built-in string functions (`lower()` and `toLowerCase()`, respectively) can directly achieve the desired conversion.
3Insight 3: When implementing the conversion manually (as in the C/C++ solutions), efficient in-place modification of the string is preferable to creating a new string if possible to optimize space complexity.

📚

Key Terms Explained

For Students

String

A sequence of characters. Like a word or sentence in programming!

Edge Cases

Edge case 1: Empty string: The algorithm handles empty strings correctly because the loop will not execute, and the original empty string is returned. This is a no-op.
Edge case 2: String with no uppercase letters: The algorithm will iterate through the string, but the condition `c >= 'A' && c <= 'Z'` will always be false, so no changes will be made, and the original string will be returned.
Edge case 3: String with only uppercase letters: The algorithm will correctly convert all uppercase letters to lowercase.
Edge case 4: String with mixed-case letters, numbers, and symbols: The algorithm correctly converts only uppercase letters, leaving other characters unchanged.

⚠️

Common Mistakes to Avoid

✗Common mistake 1: Forgetting to handle non-alphabetic characters: Ensure the code only modifies uppercase letters and leaves other characters untouched.

✗Common mistake 2: Incorrectly calculating the lowercase equivalent: The difference between 'a' and 'A' must be added to the uppercase letter's ASCII value to get the correct lowercase equivalent.

✗Common mistake 3: Trying to modify strings in place in languages where strings are immutable (like Python and Java without using StringBuilder): This will lead to errors or unexpected behavior. Instead, create a new string or use mutable string representations.

✅

Learning Tip

Every mistake is a learning opportunity! When you make an error, understand why it happened before moving on.

🌍

Where is This Used in Real Life?

💼Real-world scenario 1: Data normalization: Converting text to lowercase is a common step in data cleaning and normalization to ensure consistency and avoid case-sensitive issues during comparisons and searches.

🏦Real-world scenario 2: Case-insensitive search: When implementing search functionality, converting both the search query and the data to lowercase allows for case-insensitive matching.

🎮Real-world scenario 3: User input validation: Converting user input to lowercase can simplify validation and prevent errors caused by inconsistent capitalization.

💡Understanding real-world applications helps you see the "why" behind algorithms. It's not just about passing interviews—these concepts power the apps and websites you use every day!

Author's Notes

💡 Key Insight

String problems often involve sliding windows or two pointers. Consider if the character set is limited (lowercase letters = only 26 possibilities).

🎯 Interview Tip

Use this problem to demonstrate clean code practices. Variable naming and code organization matter.

⚠️ Watch Out

Mutating strings directly in languages where strings are immutable. Use StringBuilder or arrays.

Written by Saswata Mondal

Software Engineer • Algorithms Enthusiast • Interview Coach

👨‍💻

About the Author

👨‍💻

Saswata MondalAuthor400+ LC Problems

B.Tech CSE, IEM Kolkata | LeetCode Rating: 1672 (Top 15%)

Certified: IBM Java Developer, NPTEL Programming in Java

Last updated: November 17, 2024LeetCode Profile GitHub

This solution has been crafted based on my experience solving 400+ LeetCode problems. Each explanation is designed to help you understand the underlying concepts, not just memorize the code.

Community Tips & Insights

In a real interview, always clarify constraints first. Ask about input size and value ranges.

@TechLeadJul 14

Don't forget to handle the edge case when the input is empty. Many candidates miss this in interviews.

@DevExpert92Jul 7

The key insight here is recognizing the pattern. Once you see it, the solution becomes straightforward.

@AlgoMasterJun 30

❓

Frequently Asked Questions

What is the sliding window technique for string problems?

Sliding window maintains a "window" of characters with two pointers. Expand the right pointer to include characters, shrink from left when window violates constraints. Useful for substring problems, anagrams, and longest/shortest substring with properties.

What should I learn from easy problems?

Easy problems introduce core patterns that appear in harder problems. Master basic operations (iteration, conditionals, simple data structures), recognize common patterns (counting, searching, basic transformations), and practice explaining your thought process clearly.

What is the importance of time and space complexity analysis?

Complexity analysis is crucial because: 1) Interviewers always ask about it, 2) It helps you choose between approaches, 3) It demonstrates CS fundamentals. Always state both time and space complexity, and be prepared to explain how you derived them.

What is the optimal approach for "To Lower Case"?

For this easy-level String problem, the key is to identify the core pattern. Analyze the input constraints to determine acceptable time complexity. Consider whether standard techniques can optimize the solution. Always handle edge cases and validate your approach with examples before coding.

🤖 Need help with this problem?