Imagine you're standing in front of a massive pile of unsorted mail. Your boss tells you to find the very first letter in that pile that comes from a sender who only sent one single letter. You can't just pick up the first envelope and say "this is it," because you have no idea if that same person sent five more letters further down the stack. To solve this, you'd probably do two things: first, you'd go through the whole pile and make a tally sheet of how many letters every single person sent. Then, you'd go back to the start of the pile and check your tally sheet for the first person who only has a "1" next to their name.

In a PHP coding interview, this is exactly how we approach the "First Non-Repeating Character" problem. We don't try to solve it in one pass because we lack the future context of the string. We use a "frequency map"—which in PHP is just an associative array—to store our tallies, and then we iterate a second time to find our winner.

The Strategy: Tallying Before Deciding

When you're in the hot seat, I want you to avoid the temptation to use nested loops. If you write a loop inside a loop to check every character against every other character, you've just created an $O(n^2)$ time complexity. For a string of 10,000 characters, that's 100 million operations. An interviewer will spot that immediately. Instead, we want a linear approach: $O(n)$.

Here is how I would walk through the implementation. We'll use the input string "swiss". We expect 'w' to be the result, since 's' repeats and 'i' comes after 'w'.

function firstNonRepeatingChar(string $str): ?string {
    $charCounts = [];

    // First pass: Build the frequency map
    // This is like making our mail tally sheet
    for ($i = 0; $i < strlen($str); $i++) {
        $char = $str[$i];
        if (!isset($charCounts[$char])) {
            $charCounts[$char] = 1;
        } else {
            $charCounts[$char]++;
        }
    }

    // Second pass: Find the first char with a count of 1
    // We loop through the string again to maintain the original order
    for ($i = 0; $i < strlen($str); $i++) {
        $char = $str[$i];
        if ($charCounts[$char] === 1) {
            return $char;
        }
    }

    return null; // No unique character found
}

Why we loop through the string twice, not the array

I've seen a lot of candidates make the mistake of looping through the $charCounts array in the second pass. In older versions of PHP, associative arrays maintained insertion order, but relying on that can be risky or confusing to the interviewer. By looping through the original string $str again, you are explicitly guaranteeing that you are checking characters in the order they appeared. It's a small detail, but it shows you're thinking about the "First" part of "First Non-Repeating Character."

Talking Through the Complexity

Once you finish the code, don't just sit in silence. This is where you earn the "Senior" label. Explain the trade-offs. I'd say something like: "The time complexity here is O(n) because we traverse the string twice. The space complexity is O(k), where k is the number of unique characters in the alphabet. Since the alphabet is finite (e.g., 256 for extended ASCII), the space complexity is effectively constant."

That level of analysis tells the interviewer that you aren't just guessing—you actually understand how your code consumes system resources.

📋 Practical Task

Implement a Unique Character Finder for Product SKUs

In many inventory systems, "ghost" SKUs are identified by having a character in their ID that doesn't repeat anywhere else in that specific ID. Your task is to write a function called findUniqueSkuChar that takes a string (the SKU) and returns the first non-repeating character. If all characters repeat, return an empty string.

Requirements:

• The function must handle empty strings gracefully.
• The time complexity must be O(n).
• Test your function with the following cases:
  • "aabbcc" → should return ""
  • "inventory123" → should return "i"
  • "apple" → should return "a"