This is a common Python (Strings) interview and practice question. Below is the full answer with a clear, step-by-step explanation.

Question

Problem Given a string, return the first character that appears exactly once. If no such character exists, return None . Input text = "swiss" Task Find the first non-repeating character. Expected Return 'w'

Answer & Explanation

**What the problem is asking**

You are given a single string `text`.
You must return the *first* character in that string that occurs exactly once.
If every character appears more than once, you should return `None`.

For the example `text = "swiss"` the characters appear as follows:

- `s` appears 3 times
- `w` appears 1 time
- `i` appears 1 time

Scanning from left to right, the first character whose total count is 1 is `w`, so the answer is `'w'`.

---

**How to solve it**

The most straightforward way is a two‑pass algorithm:

1. **Count how many times each character occurs.**
A dictionary (hash map) is perfect for this because looking up or updating a key is O(1) on average. Python’s `collections.Counter` already does exactly this, but you could also build the dictionary manually.

2. **Walk through the original string once more, in order.**
For each character, look up its count from the dictionary. The first one whose count equals 1 is the answer. As soon as you find it you can return it immediately.

If the loop finishes without finding a count of 1, return `None`.

---

**Why this works**

- The first pass guarantees that you know the *exact* frequency of every character.
- The second pass respects the original order of the string, so the first character you encounter with a count of 1 is indeed the first non‑repeating character.
- Because you stop as soon as you find a qualifying character, you never waste time scanning the rest of the string unnecessarily.

---

**Step‑by‑step example**

`text = "swiss"`

*Pass 1 – counting*

| character | count |
|-----------|-------|
| s | 3 |
| w | 1 |
| i | 1 |

*Pass 2 – scanning*

- Look at `'s'` → count = 3 → not a candidate.
- Look at `'w'` → count = 1 → **found** → return `'w'`.

---

**Complexity analysis**

- **Time:**
The first pass touches each character once → O(N).
The second pass may touch each character again in the worst case → O(N).
Total = O(N), where N = length of the input string.

- **Space:**
The dictionary stores one entry for each distinct character. In the worst case (all characters different) that is O(N) extra space.

Both bounds are optimal for this problem; you cannot determine the answer without looking at every character at least once.

---

**Reference implementation (Python)**

```python
from collections import Counter

def first_non_repeating(text):
"""
Return the first character that appears exactly once in `text`.
If no such character exists, return None.
"""
# Pass 1: count frequencies
freq = Counter(text)

# Pass 2: find the first character with count == 1
for ch in text:
if freq[ch] == 1:
return ch

# No non‑repeating character found
return None

# Example usage
print(first_non_repeating("swiss")) # prints: w
print(first_non_repeating("aabbcc")) # prints: None
```

If you prefer not to use `Counter`, the same logic can be written with a plain dictionary:

```python
def first_non_repeating(text):
freq = {}
for ch in text:
freq[ch] = freq.get(ch, 0) + 1

for ch in text:
if freq[ch] == 1:
return ch
return None
```

Both versions behave identically.

---

**Things to watch out for**

- **Empty string:** The loops simply never execute, and the function correctly returns `None`.
- **Unicode / multibyte characters:** In Python a string is a sequence of Unicode code points, so the algorithm works unchanged for characters like `'é'` or emojis.
- **Case sensitivity:** `'A'` and `'a'` are distinct keys in the dictionary. If the problem required case‑insensitive handling, you would need to normalise the string (e.g., `text.lower()`) before counting.

---

**Take‑away**

- Use a hash map (dictionary) to count frequencies in O(N) time.
- Scan the original string a second time to respect order and return the first character whose stored count is 1.
- The overall solution is linear in both time and auxiliary space, which is the best you can achieve for this task.