Loading…

easyStrings0Sometimes asked

CamelCase

Q: How do you solve CamelCase using the Split on Case Changes (Naive) approach?

When to use it: Mention to show you can tokenise, then note it allocates a list you immediately discard. The direct approach tokenises the string into the actual words, then returns how many there are. You walk the input, start a new token whenever you hit an uppercase letter, collect the tokens, and report the size. **Why it is correct.** A case change is the only word boundary in camelCase, so cutting at every uppercase letter recovers exactly the original words. The number of tokens is the answer. **Why it is heavier than needed.** To get a single integer you allocated a whole list of substrings (and possibly a rebuilt, space-separated copy of the input). That is `O(n)` extra memory and a lot of moving parts — regex edge cases, leading-empty-token handling, and so on. Since the question only asks *how many* words, you never actually need the words themselves. **The takeaway.** Producing the tokens answers a harder question than was asked. Recognising that 'count of words' is fully captured by 'count of boundary markers' lets you drop the allocation entirely. Time complexity: O(n). Space complexity: O(n).

Q: How do you solve CamelCase using the Count Uppercase Letters + 1 (Optimal) approach?

When to use it: The intended answer. Say 'each capital starts a new word, plus one for the leading lowercase word'. Initialise a word counter to `1` and increment it by one for every uppercase letter you encounter. Return the counter. **Why the seed is 1.** camelCase always opens with a lowercase word that carries no marker. That first word exists regardless of how many capitals follow, so it is counted up front. If you seeded at `0`, an all-lowercase string like `"hello"` would wrongly return `0` instead of `1`. **Why each capital adds exactly one word.** The convention guarantees that a new word begins precisely at an uppercase letter, and a word starts with a *single* capital — the rest of the word is lowercase. So there is a clean bijection: one uppercase letter ⇔ one new word boundary. Summing the boundaries and adding the unmarked first word gives `uppercase_count + 1`. **Why this beats splitting.** You answer the exact question asked — *how many* words — without ever materialising the words. There is no token list, no regex, no leading-empty-token trap. The only state is one integer, so the space is constant and the logic has almost no surface area for bugs. **The one exception to remember.** An empty string has zero words, but `uppercase_count + 1` would return `1`. Guard for empty input first when the constraints permit it, then apply the formula. Time complexity: O(n). Space complexity: O(1).

Arrays & Hashing · 31 of 83 · 5 min

A word in CamelCase notation starts with a lowercase letter; the start of each subsequent word is marked by an uppercase letter. For example, oneTwoThree has three words.

Given a camelCase string s, return the number of words it contains.

In plain English

camelCase glues words together and uses capitalisation as the only delimiter. The first word is lowercase and unmarked; each later word announces itself with a single capital letter. Counting words therefore reduces to counting capitals and adding one for that unmarked first word.

Examples

Example 1

Input: s = "saveChangesInTheEditor"
Output: 5
Note: Uppercase letters: C, I, T, E = 4. Words = 4 + 1 = 5 (save, Changes, In, The, Editor).

Example 2

Input: s = "oneTwoThree"
Output: 3
Note: Uppercase T, T = 2 → 2 + 1 = 3.

Example 3

Input: s = "alllowercase"
Output: 1
Note: No uppercase letters → 0 + 1 = 1 single word.

Constraints

1 ≤ |s| ≤ 10⁵
s contains only English letters (a–z, A–Z)
The first character is lowercase (standard camelCase, not PascalCase)

Clarifying questions4First question: Is the first letter guaranteed lowercase (camelCase) or could it be uppercase (PascalCase)?Explore questions

Q1.Is the first letter guaranteed lowercase (camelCase) or could it be uppercase (PascalCase)?
Standard camelCase starts lowercase, so the +1 accounts for that first word. If PascalCase were allowed, the leading capital would be over-counted and you'd return uppercase count directly.
Q2.Can the string contain digits or symbols?
The classic prompt is letters only. If digits could start words you'd need a richer boundary rule, but for this problem only case changes matter.
Q3.Could the input be empty?
If allowed, empty means zero words — not one. Guard for length 0 before returning count + 1.
Q4.Do I return the count or the list of words?
Just the count, which is exactly why we can avoid building any substrings.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

In camelCase the first word starts lowercase and every later word begins with an uppercase letter. So the number of words equals the number of uppercase letters plus one. Scan once, count uppercase characters, return count + 1. O(n) time, O(1) space.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you spot the bijection between uppercase letters and word boundaries, avoiding an unnecessary split into substrings just to call size().

Where candidates slip

Splitting the string with a regex on case changes and counting the parts — correct but allocates a list and is easy to get wrong on edge cases like a leading capital.

How to stand out

State the invariant out loud: 'first word has no marker, every other word starts with exactly one uppercase, so words = uppercase + 1', and call out the empty-string exception.

Choose

Compare the available approaches

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

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Split on Case Changes (Naive)	`O(n)`	`O(n)`	Mention to show you can tokenise, then note it allocates a list you immediately discard.	Read
2	Count Uppercase Letters + 1 (Optimal)Optimal	`O(n)`	`O(1)`	The intended answer. Say 'each capital starts a new word, plus one for the leading lowercase word'.	Read

Interactive decision treeInteractiveChoose the right approachFollow the branches and learn why each constraint changes the solution.Explore the full tree

Uppercase letters mark word starts

How to read it:Every capital begins a new word; the first word needs no marker, hence the +1.

Rendering diagram…

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 2

Split on Case Changes (Naive)

TimeO(n)SpaceO(n)

Mention to show you can tokenise, then note it allocates a list you immediately discard.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

You could insert a delimiter before every uppercase letter, then split into tokens and count them.

2Hint 2Explore hint

A regex like splitting before each capital, or a manual builder that adds a space before uppercase, gives you the words.

3Hint 3Explore hint

It works, but you allocate an array of substrings only to read its length — can the count come for free?

A · Core idea

The direct approach tokenises the string into the actual words, then returns how many there are. You walk the input, start a new token whenever you hit an uppercase letter, collect the tokens, and report the size.

Why it is correct. A case change is the only word boundary in camelCase, so cutting at every uppercase letter recovers exactly the original words. The number of tokens is the answer.

Why it is heavier than needed. To get a single integer you allocated a whole list of substrings (and possibly a rebuilt, space-separated copy of the input). That is O(n) extra memory and a lot of moving parts — regex edge cases, leading-empty-token handling, and so on. Since the question only asks how many words, you never actually need the words themselves.

The takeaway. Producing the tokens answers a harder question than was asked. Recognising that 'count of words' is fully captured by 'count of boundary markers' lets you drop the allocation entirely.

B · Visual dry run

Interactive dry run

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

s = "oneTwoThree"

Mark breaks

before 'T' and 'T'

State"one|Two|Three"

Final result3

C · Code with teaching comments

Reference implementation previewpublic int camelcase(String s) { if (s.isEmpty()) { return 0; } String spaced = s.replaceAll("(?=[A-Z])", " ").trim();Explore the full code

solution.javaJava

Split on Case Changes (Naive) — reference

2 teaching notes

1
public int camelcase(String s) {
2
    if (s.isEmpty()) {
3
        return 0;
4
    }
5
    // Insert a space before each capital using a look-ahead, then trim a possible
6
    // leading space.
7
    String spaced = s.replaceAll("(?=[A-Z])", " ").trim();
8
    // Split on whitespace and count tokens — correct, but allocates an array just to
9
    // read its length.
10
    return spaced.split("\\s+").length;
11
}

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

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

If a regex split produces a leading empty token (e.g. when the string starts with a capital in PascalCase), your count is off by one — exactly the kind of edge case the counting approach sidesteps.

ComplexityO(n) time, O(n) space — Building the delimited string and splitting both touch every character, so O(n) time, and the resulting list of words plus the rebuilt string cost O(n) space.

E · Edge cases and pitfalls3A leading empty token when the string starts with a capital — off-by-one.Explore edge cases

Pitfalls

A leading empty token when the string starts with a capital — off-by-one.
Allocating a token list purely to call length/len.
Regex subtleties (greedy vs anchored) that differ between Java and Python.

03.2

Approach 2 of 2 · Optimal

Count Uppercase Letters + 1 (Optimal)

TimeO(n)SpaceO(1)

The intended answer. Say 'each capital starts a new word, plus one for the leading lowercase word'.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Every word after the first begins with exactly one uppercase letter. What does that say about the relationship between capitals and words?

2Hint 2Explore hint

Capitals and 'new word' events are in one-to-one correspondence. The first word has no capital, so seed your count at 1.

3Hint 3Explore hint

Scan once, add 1 for every uppercase letter, return the running total. No splitting, no extra memory.

A · Core idea

Initialise a word counter to 1 and increment it by one for every uppercase letter you encounter. Return the counter.

Why the seed is 1. camelCase always opens with a lowercase word that carries no marker. That first word exists regardless of how many capitals follow, so it is counted up front. If you seeded at 0, an all-lowercase string like "hello" would wrongly return 0 instead of 1.

Why each capital adds exactly one word. The convention guarantees that a new word begins precisely at an uppercase letter, and a word starts with a single capital — the rest of the word is lowercase. So there is a clean bijection: one uppercase letter ⇔ one new word boundary. Summing the boundaries and adding the unmarked first word gives uppercase_count + 1.

Why this beats splitting. You answer the exact question asked — how many words — without ever materialising the words. There is no token list, no regex, no leading-empty-token trap. The only state is one integer, so the space is constant and the logic has almost no surface area for bugs.

The one exception to remember. An empty string has zero words, but uppercase_count + 1 would return 1. Guard for empty input first when the constraints permit it, then apply the formula.

B · Visual dry run

Interactive dry run

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

s = "saveChangesInTheEditor"

Array state

seed

first word 'one' → words = 1

start ↓

[0]

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

Current pointerResolved stateNot processed

Final result5

C · Code with teaching comments

solution.javaJava

Count Uppercase Letters + 1 (Optimal) — optimal

4 teaching notes

1
public int camelcase(String s) {
2
    // Empty string has zero words — the +1 formula would wrongly return 1 without this
3
    // guard.
4
    if (s.isEmpty()) {
5
        return 0;
6
    }
7
    // Seed for the leading lowercase word that carries no uppercase marker.
8
    int words = 1;
9
    for (int i = 0; i < s.length(); i++) {
10
        // Each capital marks the start of a new word — locale-safe uppercase test.
11
        if (Character.isUpperCase(s.charAt(i))) {
12
            // One capital ⇔ one new word boundary.
13
            words++;
14
        }
15
    }
16
    return words;
17
}

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

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

The trick is recognising the bijection: in camelCase, 'number of word boundaries' literally equals 'number of uppercase letters'. Once boundaries map to a countable per-character property, you collapse a tokenising problem into a single counting loop.

ComplexityO(n) time, O(1) space — One pass over n characters with a constant-time uppercase test each → O(n) time. Only an integer counter is kept → O(1) space.

E · Edge cases and pitfalls6s = "a" — No capitals → 0 + 1 = 1 word.Explore edge cases

Edge cases handled

s = "a"No capitals → 0 + 1 = 1 word.
s = "alllowercase"Still one word; the seed handles the all-lowercase case.
s = "" (if permitted)Guard returns 0 — empty has no words, not one.

Pitfalls

Seeding the count at 0 — an all-lowercase string then returns 0 instead of 1.
Forgetting the empty-string guard — the formula returns 1 for no words.
Assuming PascalCase: a leading capital would be over-counted by the +1.

Practice

Try the solution yourself

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

Editable code previewpublic int camelcase(String s) { if (s.isEmpty()) { return 0; } int words = 1;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.

Forgetting the +1 for the first word

The first word has no uppercase marker, so counting only capitals undercounts by one for every camelCase string.

Explore the code comparison

Don't write this

int words = 0;
for (char c : s.toCharArray()) {
    if (Character.isUpperCase(c)) words++;
}
return words;

Write this instead

int words = 1;
for (char c : s.toCharArray()) {
    if (Character.isUpperCase(c)) words++;
}
return words;

Off-by-one from a leading empty token

Splitting before each capital on a PascalCase string yields an empty first token, inflating the count by one.

Explore the code comparison

Don't write this

return len(re.split(r'(?=[A-Z])', s))

Write this instead

return 1 + sum(1 for c in s if c.isupper())

Returning 1 for an empty string

An empty input contains zero words, but the +1 formula returns 1 unless you guard for emptiness first.

Explore the code comparison

Don't write this

return 1 + sum(1 for c in s if c.isupper())

Write this instead

if not s:
    return 0
return 1 + sum(1 for c in s if c.isupper())

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Word count = uppercase count + 1

Code pattern to memorize

words = 1
for c in s:
    if c.isUpperCase():
        words += 1
return words

Rules to remember

1Each new word (after the first) is signalled by exactly one uppercase letter — so uppercase letters and word-boundaries are in bijection.
2Start the count at 1 for the leading lowercase word, then add one per uppercase letter.
3Empty string is a special case: there are zero words, not one — guard for it if the constraints allow empty input.
4Detect uppercase with Character.isUpperCase(c) / c.isupper(), not an ASCII range you might get wrong.
5You never split the string — splitting allocates; counting does not.

Use this pattern when

Tokens are delimited by a case change rather than a separator character
You only need the count of tokens, not the tokens themselves
The first token is special (no leading delimiter) so you seed the count at 1
A single linear scan over characters suffices

Choose another pattern when

Words are separated by spaces or punctuation → split on the delimiter instead
You must return the actual words → you build a list, not a counter
Mixed conventions (snake_case + camelCase) appear → counting uppercase alone is wrong
PascalCase where the first word is also capitalised → the +1 seed changes

Interview takeaway

When token boundaries are marked by a property of a single character (a case change), counting that property and adjusting for the first token gives the count in one pass — far cheaper than splitting into substrings.

Continue

Transfer the pattern to another problem

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

Transferable patternBoundary-marker counting. When tokens are delimited by a per-character property (here, an uppercase letter) and you only need the count, tally that property in one pass and adjust for the unmarked first token instead of splitting into substrings.

Practice queueDirect variations and pattern siblings

Direct follow-ups

CamelCase to snake_case
Coming soon
Now you must emit the words: insert '_' before each capital and lowercase it.
Count words in PascalCase
Coming soon
First word is also capitalised, so words = uppercase count (no +1).
Split camelCase into the actual words
Coming soon
Return the tokens — the harder version where allocation is unavoidable.
Goat Latin
Coming soon
Per-word transformation that also keys off word boundaries and casing.

Same pattern

←

Caesar Cipher

Continue · Next problem

Counting Valleys

easyStrings0Sometimes asked

CamelCase

Arrays & Hashing · 31 of 83 · 5 min

A word in CamelCase notation starts with a lowercase letter; the start of each subsequent word is marked by an uppercase letter. For example, oneTwoThree has three words.

Given a camelCase string s, return the number of words it contains.

In plain English

Examples

Example 1

Input: s = "saveChangesInTheEditor"
Output: 5
Note: Uppercase letters: C, I, T, E = 4. Words = 4 + 1 = 5 (save, Changes, In, The, Editor).

Example 2

Input: s = "oneTwoThree"
Output: 3
Note: Uppercase T, T = 2 → 2 + 1 = 3.

Example 3

Input: s = "alllowercase"
Output: 1
Note: No uppercase letters → 0 + 1 = 1 single word.

Constraints

1 ≤ |s| ≤ 10⁵
s contains only English letters (a–z, A–Z)
The first character is lowercase (standard camelCase, not PascalCase)

Clarifying questions4First question: Is the first letter guaranteed lowercase (camelCase) or could it be uppercase (PascalCase)?Explore questions

Q1.Is the first letter guaranteed lowercase (camelCase) or could it be uppercase (PascalCase)?
Standard camelCase starts lowercase, so the +1 accounts for that first word. If PascalCase were allowed, the leading capital would be over-counted and you'd return uppercase count directly.
Q2.Can the string contain digits or symbols?
The classic prompt is letters only. If digits could start words you'd need a richer boundary rule, but for this problem only case changes matter.
Q3.Could the input be empty?
If allowed, empty means zero words — not one. Guard for length 0 before returning count + 1.
Q4.Do I return the count or the list of words?
Just the count, which is exactly why we can avoid building any substrings.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you spot the bijection between uppercase letters and word boundaries, avoiding an unnecessary split into substrings just to call size().

Where candidates slip

Splitting the string with a regex on case changes and counting the parts — correct but allocates a list and is easy to get wrong on edge cases like a leading capital.

How to stand out

State the invariant out loud: 'first word has no marker, every other word starts with exactly one uppercase, so words = uppercase + 1', and call out the empty-string exception.

Choose

Compare the available approaches

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

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Split on Case Changes (Naive)	`O(n)`	`O(n)`	Mention to show you can tokenise, then note it allocates a list you immediately discard.	Read
2	Count Uppercase Letters + 1 (Optimal)Optimal	`O(n)`	`O(1)`	The intended answer. Say 'each capital starts a new word, plus one for the leading lowercase word'.	Read

Interactive decision treeInteractiveChoose the right approachFollow the branches and learn why each constraint changes the solution.Explore the full tree

Uppercase letters mark word starts

How to read it:Every capital begins a new word; the first word needs no marker, hence the +1.

Rendering diagram…

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 2

Split on Case Changes (Naive)

TimeO(n)SpaceO(n)

Mention to show you can tokenise, then note it allocates a list you immediately discard.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

You could insert a delimiter before every uppercase letter, then split into tokens and count them.

2Hint 2Explore hint

A regex like splitting before each capital, or a manual builder that adds a space before uppercase, gives you the words.

3Hint 3Explore hint

It works, but you allocate an array of substrings only to read its length — can the count come for free?

A · Core idea

Why it is correct. A case change is the only word boundary in camelCase, so cutting at every uppercase letter recovers exactly the original words. The number of tokens is the answer.

B · Visual dry run

Interactive dry run

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

s = "oneTwoThree"

Mark breaks

before 'T' and 'T'

State"one|Two|Three"

Final result3

C · Code with teaching comments

Reference implementation previewpublic int camelcase(String s) { if (s.isEmpty()) { return 0; } String spaced = s.replaceAll("(?=[A-Z])", " ").trim();Explore the full code

solution.javaJava

Split on Case Changes (Naive) — reference

2 teaching notes

1
public int camelcase(String s) {
2
    if (s.isEmpty()) {
3
        return 0;
4
    }
5
    // Insert a space before each capital using a look-ahead, then trim a possible
6
    // leading space.
7
    String spaced = s.replaceAll("(?=[A-Z])", " ").trim();
8
    // Split on whitespace and count tokens — correct, but allocates an array just to
9
    // read its length.
10
    return spaced.split("\\s+").length;
11
}

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

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

If a regex split produces a leading empty token (e.g. when the string starts with a capital in PascalCase), your count is off by one — exactly the kind of edge case the counting approach sidesteps.

ComplexityO(n) time, O(n) space — Building the delimited string and splitting both touch every character, so O(n) time, and the resulting list of words plus the rebuilt string cost O(n) space.

E · Edge cases and pitfalls3A leading empty token when the string starts with a capital — off-by-one.Explore edge cases

Pitfalls

A leading empty token when the string starts with a capital — off-by-one.
Allocating a token list purely to call length/len.
Regex subtleties (greedy vs anchored) that differ between Java and Python.

03.2

Approach 2 of 2 · Optimal

Count Uppercase Letters + 1 (Optimal)

TimeO(n)SpaceO(1)

The intended answer. Say 'each capital starts a new word, plus one for the leading lowercase word'.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Every word after the first begins with exactly one uppercase letter. What does that say about the relationship between capitals and words?

2Hint 2Explore hint

Capitals and 'new word' events are in one-to-one correspondence. The first word has no capital, so seed your count at 1.

3Hint 3Explore hint

Scan once, add 1 for every uppercase letter, return the running total. No splitting, no extra memory.

A · Core idea

Initialise a word counter to 1 and increment it by one for every uppercase letter you encounter. Return the counter.

The one exception to remember. An empty string has zero words, but uppercase_count + 1 would return 1. Guard for empty input first when the constraints permit it, then apply the formula.

B · Visual dry run

Interactive dry run

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

s = "saveChangesInTheEditor"

Array state

seed

first word 'one' → words = 1

start ↓

[0]

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

Current pointerResolved stateNot processed

Final result5

C · Code with teaching comments

solution.javaJava

Count Uppercase Letters + 1 (Optimal) — optimal

4 teaching notes

1
public int camelcase(String s) {
2
    // Empty string has zero words — the +1 formula would wrongly return 1 without this
3
    // guard.
4
    if (s.isEmpty()) {
5
        return 0;
6
    }
7
    // Seed for the leading lowercase word that carries no uppercase marker.
8
    int words = 1;
9
    for (int i = 0; i < s.length(); i++) {
10
        // Each capital marks the start of a new word — locale-safe uppercase test.
11
        if (Character.isUpperCase(s.charAt(i))) {
12
            // One capital ⇔ one new word boundary.
13
            words++;
14
        }
15
    }
16
    return words;
17
}

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

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

ComplexityO(n) time, O(1) space — One pass over n characters with a constant-time uppercase test each → O(n) time. Only an integer counter is kept → O(1) space.

E · Edge cases and pitfalls6s = "a" — No capitals → 0 + 1 = 1 word.Explore edge cases

Edge cases handled

s = "a"No capitals → 0 + 1 = 1 word.
s = "alllowercase"Still one word; the seed handles the all-lowercase case.
s = "" (if permitted)Guard returns 0 — empty has no words, not one.

Pitfalls

Seeding the count at 0 — an all-lowercase string then returns 0 instead of 1.
Forgetting the empty-string guard — the formula returns 1 for no words.
Assuming PascalCase: a leading capital would be over-counted by the +1.

Practice

Try the solution yourself

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

Editable code previewpublic int camelcase(String s) { if (s.isEmpty()) { return 0; } int words = 1;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.

Forgetting the +1 for the first word

The first word has no uppercase marker, so counting only capitals undercounts by one for every camelCase string.

Explore the code comparison

Don't write this

int words = 0;
for (char c : s.toCharArray()) {
    if (Character.isUpperCase(c)) words++;
}
return words;

Write this instead

int words = 1;
for (char c : s.toCharArray()) {
    if (Character.isUpperCase(c)) words++;
}
return words;

Off-by-one from a leading empty token

Splitting before each capital on a PascalCase string yields an empty first token, inflating the count by one.

Explore the code comparison

Don't write this

return len(re.split(r'(?=[A-Z])', s))

Write this instead

return 1 + sum(1 for c in s if c.isupper())

Returning 1 for an empty string

An empty input contains zero words, but the +1 formula returns 1 unless you guard for emptiness first.

Explore the code comparison

Don't write this

return 1 + sum(1 for c in s if c.isupper())

Write this instead

if not s:
    return 0
return 1 + sum(1 for c in s if c.isupper())

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Word count = uppercase count + 1

Code pattern to memorize

words = 1
for c in s:
    if c.isUpperCase():
        words += 1
return words

Rules to remember

1Each new word (after the first) is signalled by exactly one uppercase letter — so uppercase letters and word-boundaries are in bijection.
2Start the count at 1 for the leading lowercase word, then add one per uppercase letter.
3Empty string is a special case: there are zero words, not one — guard for it if the constraints allow empty input.
4Detect uppercase with Character.isUpperCase(c) / c.isupper(), not an ASCII range you might get wrong.
5You never split the string — splitting allocates; counting does not.

Use this pattern when

Tokens are delimited by a case change rather than a separator character
You only need the count of tokens, not the tokens themselves
The first token is special (no leading delimiter) so you seed the count at 1
A single linear scan over characters suffices

Choose another pattern when

Words are separated by spaces or punctuation → split on the delimiter instead
You must return the actual words → you build a list, not a counter
Mixed conventions (snake_case + camelCase) appear → counting uppercase alone is wrong
PascalCase where the first word is also capitalised → the +1 seed changes

Interview takeaway

Continue

Transfer the pattern to another problem

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

Practice queueDirect variations and pattern siblings

Direct follow-ups

CamelCase to snake_case
Coming soon
Now you must emit the words: insert '_' before each capital and lowercase it.
Count words in PascalCase
Coming soon
First word is also capitalised, so words = uppercase count (no +1).
Split camelCase into the actual words
Coming soon
Return the tokens — the harder version where allocation is unavoidable.
Goat Latin
Coming soon
Per-word transformation that also keys off word boundaries and casing.

Same pattern

←

Caesar Cipher

Continue · Next problem

Counting Valleys