SpaceComplexity — AI-Powered Technical Interview Prep

Most string problems smuggle in a quiet little constraint: "The input consists of lowercase English letters." That single sentence is doing a lot of weight-lifting. It grants you permission to build a frequency array of size 26, subtract 'a' from everything, and sleep soundly.

Remove it. Now you have a whole class of bugs that pass every test case and silently corrupt real input in production. The kind of bugs users find by typing their name and watching your app explode.

ASCII Is a 128-Character Table, Nothing More

ASCII stands for American Standard Code for Information Interchange, published in 1963. It maps 128 characters to integers 0 through 127, stored in 7 bits. That's it. Your entire keyboard fits in 7 bits with room to spare.

The layout matters:

0 to 31: control characters (tab, newline, carriage return)
32 to 126: printable characters (space, digits, letters, punctuation)
127: the DEL control character

The ranges you'll actually use in interviews:

48 to 57: digits 0 through 9
65 to 90: uppercase A through Z
97 to 122: lowercase a through z

That last range is where the classic array trick comes from. ord('a') = 97 and ord('z') = 122, so ord(c) - ord('a') maps any lowercase letter to an index from 0 to 25. Clean. Fast. O(1) space. It works because the letters sit in a contiguous block. It works only because the input is ASCII.

Unicode Is Every Character Humans Have Ever Written

ASCII handled English. The rest of the world's seven billion people still needed computers.

Unicode assigns a unique integer called a code point to every character in every writing system. The current standard covers about 149,000 assigned characters across 1,114,112 possible slots, from U+0000 to U+10FFFF. Latin scripts, CJK ideographs, Arabic, Devanagari, Cyrillic, emoji, ancient Sumerian, musical notation. All of it.

The space divides into 17 planes of 65,536 code points each. The first plane, U+0000 to U+FFFF, is the Basic Multilingual Plane (BMP). It holds virtually every modern language character. Emoji and more exotic scripts live in the supplementary planes above U+FFFF.

A few examples:

'A' is U+0041
'中' (CJK for "middle") is U+4E2D
'😀' is U+1F600, in the supplementary planes

The first 128 Unicode code points are identical to ASCII. That backward compatibility is intentional and probably the single best engineering decision of the 1990s.

UTF-8 Is How Unicode Gets Stored as Bytes

Unicode defines code points. It does not define how to store them in memory. That is what an encoding does.

UTF-8 is a variable-width encoding that uses 1 to 4 bytes per character, and every ASCII character takes exactly 1 byte. That backward compatibility is why UTF-8 covers over 97% of web pages. It is the default encoding everywhere you want a default.

Code point range	Bytes
U+0000 to U+007F (ASCII)	1
U+0080 to U+07FF (Latin extended, Greek, Cyrillic)	2
U+0800 to U+FFFF (BMP, includes CJK)	3
U+10000 to U+10FFFF (emoji, supplementary)	4

Character count and byte count diverge right here. "中" is one character, three bytes. "😀" is one character, four bytes. Your len() call is lying to you in most languages, and most languages are too polite to mention it.

The Assumption Nobody States Out Loud

Most LeetCode solutions that work on strings have a hidden dependency baked in: each element is one character, and all characters come from a small, predictable set.

When the problem says "lowercase English letters," it is handing you a license to use a fixed-size array. When it says "any character," that license is revoked.

The frequency array trick collapses the moment you step outside ASCII:

# Works only if every char is lowercase ASCII a-z
freq = [0] * 26
for c in s:
    freq[ord(c) - ord('a')] += 1  # ord('中') - ord('a') = 20080, out of bounds

The fix is a hash map:

from collections import Counter
freq = Counter(s)  # Works for any Unicode input

The performance cost is real. Hash maps have higher constant factors than a 26-slot array. But correctness comes before micro-optimization, and any interview that allows arbitrary Unicode input expects the hash map approach.

Perfectly coded app with 100% test coverage getting hit by 'user enters emoji in the name field' arrow

The constraint said "lowercase English letters." It was fine. Everything was fine.

Python Gets This Right. Java Has a Landmine.

In Python 3, strings are sequences of Unicode code points. len() returns the number of code points, not bytes. No traps. No footguns. Someone made a good decision.

s = "😀"
len(s)                     # 1  (one code point)
len(s.encode('utf-8'))     # 4  (four bytes)

s = "中国"
len(s)                     # 2  (two code points)
len(s.encode('utf-8'))     # 6  (six bytes)

Slicing, iteration, and indexing all work on code points. The encoding details stay hidden unless you call .encode() yourself. For interview problems, Python handles Unicode correctly with no extra effort. It is the happy path.

Java is a different story. In Java, String is stored as UTF-16, and char is a 16-bit UTF-16 code unit, not a Unicode code point. Characters in the BMP fit in one char. Characters above U+FFFF, including most emoji, require two char values called a surrogate pair. Most Java developers have no idea this is happening under the hood.

This makes String.length() return UTF-16 code units, not characters:

String s = "😀";
s.length();                      // 2  (two UTF-16 code units)
s.codePointCount(0, s.length()); // 1  (one actual character)

And charAt(i) can hand you half a surrogate pair, which is not a valid character:

String s = "😀A";
char c0 = s.charAt(0);  // 0xD83D: high surrogate, meaningless alone
char c1 = s.charAt(1);  // 0xDE00: low surrogate, meaningless alone
char c2 = s.charAt(2);  // 'A', fine, you got lucky

The correct approach when input may contain supplementary characters:

// Option 1: iterate by code point
for (int i = 0; i < s.length(); ) {
    int cp = s.codePointAt(i);
    // process cp
    i += Character.charCount(cp);
}

// Option 2: convert to code point array upfront
int[] codePoints = s.codePoints().toArray();
for (int cp : codePoints) {
    // each cp is a valid Unicode code point
}

If the constraints guarantee ASCII-only input, charAt() and length() are fine. The moment you see "any Unicode character" or an emoji in the examples, switch to code point iteration.

Java programmer rewriting C++ to look like Java's System.out.println with nested classes and boilerplate

Java string handling when emoji are involved: perfectly straightforward, just add three more methods you've never heard of.

What This Means for Time and Space

Space for character frequency storage is the main place encoding shows up in complexity analysis. An array of size 26 is O(1) space. Works for lowercase ASCII. An array of size 128 handles all of ASCII. For full Unicode, you need a hash map: O(k) space where k is the number of distinct characters. For most interview problems with a bounded character set, k is a constant, so the complexity rarely changes but the correctness always does.

String comparison and hashing in Python are O(n) in character count. Neither is affected by byte width because the language abstracts over it. In Java, the same holds at the String level, but if you're manually working with char arrays and your input contains supplementary characters, you might be processing twice as many elements as you expect.

Ask This Question. Every Single Time.

Interviewers notice when you catch the constraint that nobody bothered to write down.

If a string problem does not specify the character set, ask. The question takes three seconds and signals that you know the answer depends on it.

A concrete script: "Are we guaranteed ASCII input, or could this contain arbitrary Unicode like CJK or emoji? That affects whether I use a frequency array or a hash map."

If they say ASCII, use the array and briefly explain why. If they say arbitrary Unicode, switch to a hash map and mention the Java surrogate pair issue if you're coding in Java. Either way you've just demonstrated something most candidates never think about.

That's the kind of assumption-catching that SpaceComplexity trains in mock interviews: flagging encoding edge cases out loud before they become bugs. The platform runs voice-based DSA interviews with rubric feedback, so you're practicing the narration, not just the code.

Quick Reference

Concept	What it is
ASCII	128-character table, 7-bit, integers 0-127
Unicode	1.1M+ code points, U+0000 to U+10FFFF
UTF-8	Variable-width encoding, 1-4 bytes, backward compatible with ASCII
UTF-16	Variable-width encoding, 1-2 code units, used internally by Java
Python `len(s)`	Code point count, never byte count
Java `String.length()`	UTF-16 code unit count, not character count
Java `charAt(i)`	UTF-16 code unit, may be an unpaired surrogate
Java `codePointAt(i)`	Actual Unicode code point, safe for all characters
Array of 26 trick	Valid only for lowercase ASCII a-z
Hash map	Correct for any character set

ASCII vs Unicode: The Encoding Gap Every String Problem Assumes