First Non-Repeating Character in a String

Introduction

Strings are everywhere in programming — names, passwords, messages, URLs. And one of the most common string problems you will face, both in interviews and real coding tasks, is finding the first non-repeating character in a string.

So what does that mean? Let's say you have the word "programming". Some characters appear more than once — like p, r, g, m. But some characters appear only once. The first one from the left that appears exactly once — that is the answer.

This problem is a great exercise for beginners because it teaches you how to count things, loop through a string, and think clearly about logic. Let's break it all down, step by step.

Problem Statement

Given a string of characters, your task is to find the first unique character — that is, the first character that appears exactly once in the entire string, reading from left to right.

If every character repeats (no character is unique), print or return a message saying none was found.

Input Format

The input is one string. It can contain lowercase letters, uppercase letters, or both. For this solution we treat uppercase and lowercase as the same character (we convert everything to lowercase first). The string can be of any length, including zero.

Output Format

If a first unique character exists, print it. If every character in the string repeats, print a clear message saying none was found.

Flowchart

Here is the step-by-step logic before we write any code. Follow the arrows from top to bottom.

Pseudocode

Before writing real Python, it helps to plan the logic in plain steps. This pseudocode shows exactly what the program does:

Python Program

Here is the complete, working Python program. It is clean, simple, and easy for beginners to follow.

# Program: First Non-Repeating Character in a String

def find_first_non_repeating(input_string):
    """Find and return the first character that appears only once."""

    # Step 1: Convert to lowercase for case-insensitive comparison
    s = input_string.lower()

    # Step 2: Build a frequency dictionary to count each character
    freq = {}
    for char in s:
        if char in freq:
            freq[char] += 1
        else:
            freq[char] = 1

    # Step 3: Loop through the string again (left to right)
    #         Return the first character whose count is exactly 1
    for char in s:
        if freq[char] == 1:
            return char

    # Step 4: If no unique character was found, return None
    return None


# ── Main Program ──────────────────────────────────────
user_input = input("Enter a string: ")

result = find_first_non_repeating(user_input)

if result:
    print(f"First non-repeating character: {result}")
else:
    print("No non-repeating character found.")

Explanation of the Program

Let's walk through each part of the code so you understand exactly what is happening:

Time Complexity

We go through the string twice — once to build the frequency dictionary, and once to find the first unique character. Both loops are linear, so the total time complexity is O(n), where n is the length of the string. This is efficient — even for very long strings it runs fast.

The dictionary lookups (freq[char]) happen in constant time — O(1) on average — so they don't add extra cost.

Space Complexity

We use a dictionary to store the count of each unique character. The number of unique characters is at most 26 (for lowercase English letters). So the extra space used does not grow with the string length — it is bounded by the size of the alphabet.

This means the space complexity is O(1) in practical terms (or O(k) where k is the character set size, which is fixed at 26 for English letters).

Test Cases

Let's verify our algorithm works correctly across different inputs:

Trace for Test Case 1 — "leetcode"

Conclusion

Finding the first non-repeating character in a string is one of those classic problems that teaches you a lot with very little code. The key idea is simple: count the frequency of every character first, then scan left to right to find the first one that appeared only once.

Our Python solution does this cleanly with two loops and a dictionary. It runs in O(n) time and uses barely any extra memory. More importantly, the logic is easy to understand — which makes it perfect for students just getting started with string algorithms.

Once you are comfortable with this approach, try extending it: what if you need the last non-repeating character? What if the string includes spaces or numbers? These small changes are great practice.