How do I practice coding and algorithm questions?

Use PracHub's coding console to write, test, and debug your solutions in Python or JavaScript. View hints, test against sample inputs, and compare with official solutions.

What difficulty level is this coding question?

This is a medium difficulty Coding & Algorithms question, commonly asked during Technical Screen rounds at Antra.

What role is this question designed for?

This question is commonly asked for Software Engineer candidates at Antra during technical interviews.

Character Frequency Count in a String

Quick Overview

This question tests a candidate's practical ability to traverse strings and use hash-based data structures for frequency counting while preserving insertion order. It evaluates core algorithmic thinking in the Coding & Algorithms domain, commonly asked to assess proficiency with hash maps and attention to edge cases like case sensitivity.

Company: Antra

Role: Software Engineer

Category: Coding & Algorithms

Difficulty: medium

Interview Round: Technical Screen

## Character Frequency Count in a String Given a string `s`, count how many times each character occurs in it and return the per-character frequencies. Process the characters in the **order of first appearance**: the output must list each distinct character the first time it is seen, from left to right, paired with its total number of occurrences across the whole string. The comparison is case-sensitive, so `'A'` and `'a'` are different characters, and whitespace characters (such as a space) count as characters. ### Output Format Return a list of `(character, count)` pairs ordered by each character's first occurrence in `s`. For an empty input string, return an empty list. ### Examples Example 1: - Input: `s = "hello"` - Output: `[('h', 1), ('e', 1), ('l', 2), ('o', 1)]` - Explanation: `'h'` appears first and occurs once; `'e'` next, once; `'l'` next, twice; `'o'` last, once. Example 2: - Input: `s = "aabbbc"` - Output: `[('a', 2), ('b', 3), ('c', 1)]` Example 3: - Input: `s = "AaAa"` - Output: `[('A', 2), ('a', 2)]` - Explanation: Uppercase and lowercase are treated as distinct characters. Example 4: - Input: `s = ""` - Output: `[]` ### Constraints - `0 <= s.length <= 10^5` - `s` consists of printable ASCII characters (character codes 32 through 126), including spaces. ### Required Function Implement a function that takes the string `s` and returns the list of `(character, count)` pairs ordered by first appearance.

Quick Answer: This question tests a candidate's practical ability to traverse strings and use hash-based data structures for frequency counting while preserving insertion order. It evaluates core algorithmic thinking in the Coding & Algorithms domain, commonly asked to assess proficiency with hash maps and attention to edge cases like case sensitivity.

Given a string `s`, count how many times each character occurs in it and return the per-character frequencies. Process the characters in the **order of first appearance**: the output must list each distinct character the first time it is seen, from left to right, paired with its total number of occurrences across the whole string. The comparison is case-sensitive, so `'A'` and `'a'` are different characters, and whitespace characters (such as a space) count as characters. **Output Format:** Return a list of `(character, count)` pairs ordered by each character's first occurrence in `s`. For an empty input string, return an empty list. **Examples:** - `s = "hello"` → `[('h', 1), ('e', 1), ('l', 2), ('o', 1)]` - `s = "aabbbc"` → `[('a', 2), ('b', 3), ('c', 1)]` - `s = "AaAa"` → `[('A', 2), ('a', 2)]` (uppercase and lowercase are distinct) - `s = ""` → `[]`

Constraints

0 <= s.length <= 10^5
s consists of printable ASCII characters (codes 32 through 126), including spaces.
Comparison is case-sensitive: 'A' and 'a' are different characters.

Examples

Input: ("hello",)

Expected Output: [('h', 1), ('e', 1), ('l', 2), ('o', 1)]

Explanation: 'h' is seen first (1 time), then 'e' (1), then 'l' (2 across the string), then 'o' (1), in first-appearance order.

Input: ("aabbbc",)

Expected Output: [('a', 2), ('b', 3), ('c', 1)]

Explanation: 'a' appears twice, 'b' three times, 'c' once, listed in the order each is first encountered.

Input: ("AaAa",)

Expected Output: [('A', 2), ('a', 2)]

Explanation: Case-sensitive: 'A' and 'a' are distinct, each occurring twice; 'A' is seen first.

Input: ("",)

Expected Output: []

Explanation: Empty input yields an empty list.

Input: ("a",)

Expected Output: [('a', 1)]

Explanation: Single character occurs once.

Input: ("a b a",)

Expected Output: [('a', 2), (' ', 2), ('b', 1)]

Explanation: Whitespace counts as a character: 'a' twice, the space twice, 'b' once, in first-appearance order.

Input: ("112233!!",)

Expected Output: [('1', 2), ('2', 2), ('3', 2), ('!', 2)]

Explanation: Digits and punctuation are counted like any other characters.

Hints

Iterate through the string once, maintaining a count for each character in a hash map.
To preserve first-appearance order, record each character in a separate list the first time you see it (or rely on an insertion-ordered map).
A space and punctuation are characters too — do not skip or normalize them.

Quick Overview