Loading…

easyBasicsSometimes asked

Convert to Uppercase

Basics · 6 min

Given a string s, return it with every lowercase letter converted to uppercase. Non-letters are unchanged.

In plain English

Lowercase letters sit 32 positions above uppercase in ASCII; subtract 32 (or use a library call).

Examples

Example 1

Input: s = "hello"
Output: "HELLO"
Note: All upper-cased.

Example 2

Input: s = "aBc1"
Output: "ABC1"
Note: Digit unchanged.

Example 3

Input: s = "X"
Output: "X"
Note: Already upper.

Constraints

0 ≤ s.length ≤ 10^4

Clarifying questions1First question: ASCII only or full Unicode?Explore questions

Q1.ASCII only or full Unicode?
Manual shift is ASCII; I'd use the library for locale-correct casing.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

For each char, if it's between 'a' and 'z', subtract 32 from its ASCII code; leave everything else alone. Or just call `toUpperCase()`.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you know the 32 ASCII offset and guard the letter range.

Where candidates slip

Wrong direction, or shifting non-letters.

How to stand out

Mention locale-aware toUpperCase for non-ASCII correctness.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 1 · Optimal

ASCII shift

TimeO(n)SpaceO(n)

This is the standard, expected solution — lead with it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

What's the fixed ASCII gap between 'a' and 'A'?

2Hint 2Explore hint

Subtract 32 from a–z letters; guard the range.

3Hint 3Explore hint

Leave digits, spaces, and symbols unchanged.

A · Core idea

Convert lowercase to uppercase with an ASCII shift: lowercase letters sit exactly 32 code points above their uppercase forms ('a'=97, 'A'=65), so subtracting 32 from an a–z letter yields its uppercase version.

Why the range guard. Only characters in 'a'..'z' should shift. Subtracting 32 blindly would corrupt digits, spaces, and symbols. Guard with 'a' <= ch <= 'z' and leave everything else untouched.

Direction matters. Subtract 32 to go up to uppercase; adding 32 would lowercase instead — a common sign slip.

In practice. You'd call toUpperCase(), which also handles locale and non-Latin scripts (e.g. Turkish 'i'). The manual shift is the ASCII-fundamentals demonstration; mention the locale nuance for credit.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

s = "aB1"

in a-z → −32

StateA

Final result"AB1"

C · Code with teaching comments

solution.javaJava

ASCII shift — optimal

1 teaching note

1
public String toUpper(String s) {
2
    char[] c = s.toCharArray();
3
    for (int i = 0; i < c.length; i++) {
4
        // Shift lowercase letters up by the 32-char case gap.
5
        if (c[i] >= 'a' && c[i] <= 'z') c[i] -= 32;
6
    }
7
    return new String(c);
8
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.8 lines

D · Why it works and complexityO(n) timeO(n) spaceOpen the invariant and proofExplore the proof

Knowing the 32 offset between cases is a classic ASCII fundamentals question.

ComplexityO(n) time, O(n) space — one range check and possible shift per character.

E · Edge cases and pitfalls5s = "hello" — → "HELLO".Explore edge cases

Edge cases handled

s = "hello"→ "HELLO".
s = "aBc1"Digit unchanged → "ABC1".
s = "X"Already upper → "X".

Pitfalls

Shifting non-letters and corrupting digits/symbols.
Adding 32 (lowercases) instead of subtracting.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic String toUpper(String s) { char[] c = s.toCharArray(); for (int i = 0; i < c.length; i++) { if (c[i] >= 'a' && c[i] <= 'z') c[i] -= 32; }Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Shifting non-letters and corrupting digits/symbols.
Adding 32 (that lowercases) instead of subtracting.

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

ASCII case shift

Code pattern to memorize

if 'a'<=ch<='z': ch -= 32

Rules to remember

1'a'-'A' = 32.
2Upper = lower − 32.
3Guard with a-z range.

Use this pattern when

ASCII case manipulation

Interview takeaway

Case conversion is a ±32 ASCII shift behind the library call.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternA core fresher pattern: ASCII case shift. Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups

easyBasicsSometimes asked

Convert to Uppercase

Basics · 6 min

Given a string s, return it with every lowercase letter converted to uppercase. Non-letters are unchanged.

In plain English

Lowercase letters sit 32 positions above uppercase in ASCII; subtract 32 (or use a library call).

Examples

Example 1

Input: s = "hello"
Output: "HELLO"
Note: All upper-cased.

Example 2

Input: s = "aBc1"
Output: "ABC1"
Note: Digit unchanged.

Example 3

Input: s = "X"
Output: "X"
Note: Already upper.

Constraints

0 ≤ s.length ≤ 10^4

Clarifying questions1First question: ASCII only or full Unicode?Explore questions

Q1.ASCII only or full Unicode?
Manual shift is ASCII; I'd use the library for locale-correct casing.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

For each char, if it's between 'a' and 'z', subtract 32 from its ASCII code; leave everything else alone. Or just call `toUpperCase()`.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you know the 32 ASCII offset and guard the letter range.

Where candidates slip

Wrong direction, or shifting non-letters.

How to stand out

Mention locale-aware toUpperCase for non-ASCII correctness.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 1 · Optimal

ASCII shift

TimeO(n)SpaceO(n)

This is the standard, expected solution — lead with it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

What's the fixed ASCII gap between 'a' and 'A'?

2Hint 2Explore hint

Subtract 32 from a–z letters; guard the range.

3Hint 3Explore hint

Leave digits, spaces, and symbols unchanged.

A · Core idea

Why the range guard. Only characters in 'a'..'z' should shift. Subtracting 32 blindly would corrupt digits, spaces, and symbols. Guard with 'a' <= ch <= 'z' and leave everything else untouched.

Direction matters. Subtract 32 to go up to uppercase; adding 32 would lowercase instead — a common sign slip.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

s = "aB1"

in a-z → −32

StateA

Final result"AB1"

C · Code with teaching comments

solution.javaJava

ASCII shift — optimal

1 teaching note

1
public String toUpper(String s) {
2
    char[] c = s.toCharArray();
3
    for (int i = 0; i < c.length; i++) {
4
        // Shift lowercase letters up by the 32-char case gap.
5
        if (c[i] >= 'a' && c[i] <= 'z') c[i] -= 32;
6
    }
7
    return new String(c);
8
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.8 lines

D · Why it works and complexityO(n) timeO(n) spaceOpen the invariant and proofExplore the proof

Knowing the 32 offset between cases is a classic ASCII fundamentals question.

ComplexityO(n) time, O(n) space — one range check and possible shift per character.

E · Edge cases and pitfalls5s = "hello" — → "HELLO".Explore edge cases

Edge cases handled

s = "hello"→ "HELLO".
s = "aBc1"Digit unchanged → "ABC1".
s = "X"Already upper → "X".

Pitfalls

Shifting non-letters and corrupting digits/symbols.
Adding 32 (lowercases) instead of subtracting.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic String toUpper(String s) { char[] c = s.toCharArray(); for (int i = 0; i < c.length; i++) { if (c[i] >= 'a' && c[i] <= 'z') c[i] -= 32; }Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Shifting non-letters and corrupting digits/symbols.
Adding 32 (that lowercases) instead of subtracting.

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

ASCII case shift

Code pattern to memorize

if 'a'<=ch<='z': ch -= 32

Rules to remember

1'a'-'A' = 32.
2Upper = lower − 32.
3Guard with a-z range.

Use this pattern when

ASCII case manipulation

Interview takeaway

Case conversion is a ±32 ASCII shift behind the library call.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternA core fresher pattern: ASCII case shift. Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups