Write a program to find the number of times an element occurs in the list.

Programming Problems · Q1

Q. Write a program to find the number of times an element occurs in the list.

Tripura TbseTextbookSubjective· 3mImportance★★★★★est

57% · 17/30 Questions

✓ Free question

Concept understanding — Element Frequency Count

Element Frequency Count — The Intuition

Imagine you have a bag of marbles. Some are red, some blue, some green. If someone asks "how many blue marbles are there?", you'd count them. That's exactly what element frequency count is — counting how many times each distinct item appears in a collection.

In programming terms, you have an array (or list) of elements, and you want to know: for each unique element, how many times does it occur?

Note

The "element" can be anything: a number, a character, a string, or even an object. The "frequency" is just the count of its occurrences.

The Precise Statement

Given a collection (array, list, string, etc.) of $n$ elements, the frequency count of an element $x$ is the number of times $x$ appears in that collection. Formally:

\text{freq}(x) = \sum_{i=1}^{n} \mathbf{1}(a_i = x)

where $\mathbf{1}(\text{condition})$ is 1 when the condition is true and 0 otherwise.

The element frequency count of the entire collection is a mapping (or dictionary) from each distinct element to its frequency.

Why It Matters

This is one of the most fundamental operations in data analysis and algorithm design. You use it to:

Find the most/least frequent element (mode)
Detect duplicates
Build histograms
Solve pattern-matching problems
Analyse text (word frequencies)

How to Compute It — The Standard Method

The simplest approach uses a hash map (dictionary):

Create an empty dictionary.
Loop through each element in the collection.
For each element:
- If it's already in the dictionary, increment its count by 1.
- Otherwise, add it to the dictionary with count 1.

In pseudocode:

freq = empty dictionary
for each element e in collection:
    if e in freq:
        freq[e] = freq[e] + 1
    else:
        freq[e] = 1
return freq

Tip

Many languages have a built-in shortcut. In Python, collections.Counter does exactly this in one line. In C++, std::unordered_map with ++freq[e] works because new keys are default-initialised to 0.

A Concrete Example

Take the array: [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

Step through:

Element	Action	Dictionary state
3	new → count=1	{3:1}
1	new → count=1	{3:1, 1:1}
4	new → count=1	{3:1, 1:1, 4:1}
1	existing → increment	{3:1, 1:2, 4:1}
5	new → count=1	{3:1, 1:2, 4:1, 5:1}
9	new → count=1	{3:1, 1:2, 4:1, 5:1, 9:1}
2	new → count=1	{3:1, 1:2, 4:1, 5:1, 9:1, 2:1}
6	new → count=1	{3:1, 1:2, 4:1, 5:1, 9:1, 2:1, 6:1}
5	existing → increment	{3:1, 1:2, 4:1, 5:2, 9:1, 2:1, 6:1}
3	existing → increment	{3:2, 1:2, 4:1, 5:2, 9:1, 2:1, 6:1}
5	existing → increment	{3:2, 1:2, 4:1, 5:3, 9:1, 2:1, 6:1}

Final result: 3 appears twice, 1 appears twice, 4 once, 5 three times, 9 once, 2 once, 6 once.

Complexity

Time: $O(n)$ — you visit each element exactly once, and dictionary operations are $O(1)$ on average.
Space: $O(k)$ where $k$ is the number of distinct elements. In the worst case (all elements distinct), $k = n$ .

Watch out

If the elements are not hashable (e.g., lists in Python, or custom objects without a proper hash), you cannot use a hash map directly. You'd need a different approach, like sorting first ( $O(n \log n)$ ) or using a balanced BST.

Common Variations

Frequency of a single element: Just count how many times that specific value appears — a simple loop with a counter.

Cumulative frequency: For sorted data, the frequency of an element plus all frequencies of elements before it.

Relative frequency: $\frac{\text{freq}(x)}{n}$ — the proportion of the collection that is $x$ .

Frequency table: A table listing each distinct element alongside its frequency, often sorted by frequency or by element value.

The Key Insight

Element frequency count is just counting with memory. Instead of recounting from scratch each time you need a count, you build a lookup table once. That's the entire idea — and it's powerful enough to be the foundation of many algorithms you'll encounter later.

list.count(x) returns the number of times x appears (0 if absent).

lst = [int(input("Element: ")) for _ in range(int(input("How many? ")))]
target = int(input("Element to count: "))
print(target, "occurs", lst.count(target), "time(s)")

How many? 6 → 4 7 4 9 4 7, count 4 → "4 occurs 3 time(s)"

✓Final answer

Use lst.count(target) after reading the list — one scan, returns the frequency (e.g. 3).

Python lists already know how to count themselves: list.count(x) returns how many times

x appears. We read the list and the element from the user, then one method call gives the answer —

no manual loop needed (though a loop version is shown too, since that is what count() does inside).

The idea

Counting occurrences means scanning the list once and adding 1 every time an element equals the

target. The built-in method count() does exactly this scan for us.

Program

# Count how many times an element occurs in a list
n = int(input("How many elements? "))
lst = []
for i in range(n):
    lst.append(int(input("Enter element " + str(i + 1) + ": ")))

target = int(input("Element to count: "))
print(target, "occurs", lst.count(target), "time(s) in", lst)

Sample run

How many elements? 6
Enter element 1: 4
Enter element 2: 7
Enter element 3: 4
Enter element 4: 9
Enter element 5: 4
Enter element 6: 7
Element to count: 4
4 occurs 3 time(s) in [4, 7, 4, 9, 4, 7]

What `count()` is doing (manual version)

count = 0
for item in lst:
    if item == target:
        count += 1
print(count)   # 3 for the run above

Key lines explained:

lst.append(...) grows the list one input at a time — the standard way to read a list of n values.
lst.count(target) walks the whole list and returns the number of elements equal to target; it returns 0 when the element is absent (no error).
The manual loop shows the same logic: initialise a counter to 0, add 1 on every match.

✓Final answer

Read the list, then use lst.count(target) — e.g. for [4, 7, 4, 9, 4, 7] and target 4 the program prints 4 occurs 3 time(s) . count() returns 0 if the element is not present.

←Previous questionQ8 — Consider the following dictionary stateCapital: stateCapital = "Assam"…→Next questionQ2 — Write a program to read a list of n integers (positive as well as nega…

Q.Write a program to find the number of times an element occurs in the list.

The idea

Program

Sample run

What count() is doing (manual version)

🎓Unlock everything free for 14 days

What `count()` is doing (manual version)

Unlock everything free for 14 days