Counting Sort Algorithm in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the counting array with the correct size.

DSA C

int count[[1]];

Drag options to blanks, or click blank then click option'

Amax

Bn + 1

Cn

Dmax + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using max instead of max + 1 causes out-of-bound errors.

Using n (array length) instead of max + 1.

The counting array size must be max + 1 to include all values from 0 to max.

2fill in blank

medium

Complete the code to initialize the counting array elements to zero.

DSA C

for (int i = 0; i < [1]; i++) {
    count[i] = 0;
}

Drag options to blanks, or click blank then click option'

An

Bmax + 1

Cmax

Dn + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Looping only n times instead of max + 1.

Looping to max instead of max + 1.

We initialize all count elements from 0 to max inclusive, so loop runs max + 1 times.

3fill in blank

hard

Fix the error in the counting step to correctly count occurrences.

DSA C

for (int i = 0; i < n; i++) {
    count[[1]]++;
}

Drag options to blanks, or click blank then click option'

Acount[i]

Bi

Carr[i]

Darr[count[i]]

Attempts:

3 left

💡 Hint

Common Mistakes

Using i as index increments wrong count.

Using count[i] as index causes errors.

We increment count at index arr[i] to count how many times each value appears.

4fill in blank

hard

Fill both blanks to compute the cumulative count correctly.

DSA C

for (int i = 1; i < [1]; i++) {
    count[i] = count[i] [2] count[i - 1];
}

Drag options to blanks, or click blank then click option'

Amax + 1

B+

C-

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction instead of addition.

Looping only to max instead of max + 1.

Loop runs from 1 to max + 1 to update counts cumulatively by adding previous count.

5fill in blank

hard

Fill all three blanks to place elements in output array correctly.

DSA C

for (int i = n - 1; i >= 0; i--) {
    output[count[[1]] - 1] = [2][i];
    count[[3]]--;
}

Drag options to blanks, or click blank then click option'

Aarr[i]

Barr

Ci

Dcount

Attempts:

3 left

💡 Hint

Common Mistakes

Using i instead of arr[i] as index.

Decrementing count[i] instead of count[arr[i]].

We use arr[i] as index for count and to place in output, then decrement count[arr[i]].

Practice

1. What is the main idea behind the Counting Sort algorithm?

easy

A. Counting the number of occurrences of each element to sort

B. Comparing each element with every other element

C. Dividing the array into halves and sorting recursively

D. Swapping adjacent elements repeatedly

Solution

1. Step 1: Understand Counting Sort principle

   Counting Sort counts how many times each value appears in the input.

2. Step 2: Use counts to place elements in order

   Using these counts, it places elements directly into the sorted output.

3. Final Answer:

   Counting the number of occurrences of each element to sort -> Option A

4. Quick Check:

   Counting occurrences = A [OK]

Hint: Counting occurrences helps sort without comparisons [OK]

Common Mistakes:

• Thinking it compares elements like bubble sort
• Confusing with divide and conquer methods
• Assuming it swaps elements repeatedly

2. Which of the following is the correct way to declare the count array in C for counting sort if the maximum value in input is max_val?

easy

A. int count[max_val + 1];

B. int count[max_val];

C. int count[max_val - 1];

D. int count[max_val * 2];

Solution

1. Step 1: Understand array size for counts

   The count array must hold counts for all values from 0 to max_val inclusive, so size is max_val + 1.

2. Step 2: Choose correct declaration

   Declaring int count[max_val + 1]; ensures space for all possible values.

3. Final Answer:

   int count[max_val + 1]; -> Option A

4. Quick Check:

   Count array size = max_val + 1 [OK]

Hint: Count array size must cover all values including max_val [OK]

Common Mistakes:

• Using max_val size misses last element count
• Using max_val - 1 causes out-of-range errors
• Using double size wastes memory unnecessarily

3. What will be the output of the counting sort on the array [4, 2, 2, 8, 3, 3, 1]?

medium

A. [1, 3, 2, 4, 8, 3, 2]

B. [1, 2, 2, 3, 3, 4, 8]

C. [8, 4, 3, 3, 2, 2, 1]

D. [2, 2, 3, 3, 4, 8, 1]

Solution

1. Step 1: Count occurrences of each element

   1 appears once, 2 appears twice, 3 appears twice, 4 once, 8 once.

2. Step 2: Place elements in sorted order using counts

   Sorted array is [1, 2, 2, 3, 3, 4, 8].

3. Final Answer:

   [1, 2, 2, 3, 3, 4, 8] -> Option B

4. Quick Check:

   Sorted array = C [OK]

Hint: Count then output in order for sorted array [OK]

Common Mistakes:

• Confusing input order with output order
• Forgetting to repeat elements by their counts
• Mixing up counts and positions

4. Given the following code snippet for counting sort, what is the error?

int count[5] = {0};
int arr[6] = {1, 3, 4, 2, 3, 0};
for (int i = 0; i < 6; i++) {
    count[arr[i]]++;
}
for (int i = 0; i <= 5; i++) {
    printf("%d ", count[i]);
}

medium

A. Incrementing count[arr[i]] is wrong

B. Count array not initialized to zero

C. Array arr size is incorrect

D. Loop accessing count array goes out of bounds

Solution

1. Step 1: Check count array size and loop range

   Count array size is 5 (indices 0 to 4), but loop runs i from 0 to 5 inclusive, accessing count[5] which is out of bounds.

2. Step 2: Identify out-of-bounds access

   Accessing count[5] causes undefined behavior or error.

3. Final Answer:

   Loop accessing count array goes out of bounds -> Option D

4. Quick Check:

   Loop index > count size = D [OK]

Hint: Check array size vs loop limits carefully [OK]

Common Mistakes:

• Ignoring array size when looping
• Assuming initialization fixes out-of-bounds
• Confusing arr size with count size

5. You want to sort an array containing negative and positive integers using counting sort. Which modification is necessary?

hard

A. Use the array as is because counting sort handles negatives naturally

B. Sort only positive numbers and ignore negatives

C. Shift all numbers by adding the absolute value of the minimum element before sorting

D. Use bubble sort instead

Solution

1. Step 1: Understand counting sort limitation

   Counting sort works only with non-negative integers because it uses array indices as counts.

2. Step 2: Adjust negative values for indexing

   Shift all numbers by adding the absolute value of the minimum element to make all values non-negative before counting.

3. Final Answer:

   Shift all numbers by adding the absolute value of the minimum element before sorting -> Option C

4. Quick Check:

   Shift negatives to non-negative = B [OK]

Hint: Shift negatives to zero or above before counting [OK]

Common Mistakes:

• Trying to count negatives directly
• Ignoring negative values in input
• Switching to other sorts unnecessarily