Bird
Raised Fist0
DSA Javaprogramming~10 mins

Radix Sort Algorithm in DSA Java - Interactive Practice

Choose your learning style10 modes available
Practice - 5 Tasks
Answer the questions below
1fill in blank
easy

Complete the code to get the maximum value from the array for Radix Sort.

DSA Java
int getMax(int[] arr) {
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] [1] max) {
            max = arr[i];
        }
    }
    return max;
}
Drag options to blanks, or click blank then click option'
A>
B<
C==
D<=
Attempts:
3 left
💡 Hint
Common Mistakes
Using '<' instead of '>' causes the max to never update correctly.
Using '==' does not update max properly.
2fill in blank
medium

Complete the code to perform counting sort on the array based on the digit represented by exp.

DSA Java
void countSort(int[] arr, int exp) {
    int n = arr.length;
    int[] output = new int[n];
    int[] count = new int[10];

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

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

    for (int i = n - 1; i >= 0; i--) {
        output[count[(arr[i] / exp) % 10] - 1] = arr[i];
        count[(arr[i] / exp) % 10]--;
    }

    for (int i = 0; i < n; i++) {
        arr[i] = output[i];
    }
}
Drag options to blanks, or click blank then click option'
An
B10
Carr[i]
Dexp
Attempts:
3 left
💡 Hint
Common Mistakes
Using 10 instead of exp ignores the current digit place.
Using arr[i] directly does not isolate the digit.
3fill in blank
hard

Fix the error in the loop that performs counting sort for Radix Sort.

DSA Java
for (int i = n - 1; i >= 0; i--) {
    output[count[(arr[i] / [1]) % 10] - 1] = arr[i];
    count[(arr[i] / [1]) % 10]--;
}
Drag options to blanks, or click blank then click option'
Ai
Bexp
Cn
D10
Attempts:
3 left
💡 Hint
Common Mistakes
Using 'i' or 'n' instead of 'exp' causes wrong digit extraction.
Using 10 ignores the current digit place.
4fill in blank
hard

Fill both blanks to complete the main Radix Sort loop that sorts by each digit place.

DSA Java
void radixSort(int[] arr) {
    int max = getMax(arr);

    for (int exp = 1; max [1] exp; exp = exp [2] 10) {
        countSort(arr, exp);
    }
}
Drag options to blanks, or click blank then click option'
A>
B<
C*
D+
Attempts:
3 left
💡 Hint
Common Mistakes
Using '>' instead of '<' causes the loop to never run.
Using '+' instead of '*' does not move to the next digit place correctly.
5fill in blank
hard

Fill all three blanks to complete the counting sort initialization and update steps.

DSA Java
void countSort(int[] arr, int exp) {
    int n = arr.length;
    int[] output = new int[n];
    int[] count = new int[10];

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

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

    // rest of the code
}
Drag options to blanks, or click blank then click option'
Aexp
B<
C+
D-
Attempts:
3 left
💡 Hint
Common Mistakes
Using wrong operators in the loop condition or accumulation causes incorrect counting.
Using '-' instead of '+' breaks the cumulative count.

Practice

(1/5)
1. What is the main idea behind the Radix Sort algorithm?
easy
A. Sort numbers digit by digit starting from the least significant digit
B. Compare each element with every other element and swap if needed
C. Divide the array into halves and sort each half recursively
D. Use a pivot element to partition the array and sort partitions

Solution

  1. Step 1: Understand Radix Sort approach

    Radix Sort sorts numbers by processing individual digits starting from the least significant digit (rightmost) to the most significant digit (leftmost).
  2. Step 2: Compare with other sorting methods

    Other options describe Bubble Sort, Merge Sort, and Quick Sort, which are different algorithms.
  3. Final Answer:

    Sort numbers digit by digit starting from the least significant digit -> Option A
  4. Quick Check:

    Radix Sort = Digit by digit sorting [OK]
Hint: Radix Sort processes digits from right to left [OK]
Common Mistakes:
  • Confusing Radix Sort with comparison-based sorts
  • Thinking it sorts from most significant digit first
  • Assuming it uses pivot or divide and conquer
2. Which of the following is the correct way to get the digit at position pos (starting from 0 for least significant digit) of a number num in Java?
easy
A. (num % (int) Math.pow(10, pos)) / 10
B. (num / (int) Math.pow(10, pos)) % 10
C. (num * (int) Math.pow(10, pos)) % 10
D. (num % 10) / (int) Math.pow(10, pos)

Solution

  1. Step 1: Understand digit extraction logic

    To get the digit at position pos, divide num by 10^pos to shift digits right, then take modulo 10 to get the last digit.
  2. Step 2: Check each option

    (num / (int) Math.pow(10, pos)) % 10 correctly divides num by 10^pos and then modulo 10. Others do incorrect operations.
  3. Final Answer:

    (num / (int) Math.pow(10, pos)) % 10 -> Option B
  4. Quick Check:

    Digit extraction = divide then modulo [OK]
Hint: Divide by 10^pos then mod 10 to get digit [OK]
Common Mistakes:
  • Using modulo before division
  • Multiplying instead of dividing
  • Incorrect order of operations
3. What will be the output array after one pass of Radix Sort on the array [170, 45, 75, 90, 802] sorting by the least significant digit (units place)?
medium
A. [45, 75, 90, 170, 802]
B. [802, 170, 90, 45, 75]
C. [170, 90, 802, 45, 75]
D. [75, 45, 170, 90, 802]

Solution

  1. Step 1: Extract least significant digit of each number

    170 -> 0, 45 -> 5, 75 -> 5, 90 -> 0, 802 -> 2
  2. Step 2: Sort array by these digits

    Order by digits: 0s first (170, 90), then 2 (802), then 5s (45, 75). So array becomes [170, 90, 802, 45, 75]
  3. Final Answer:

    [170, 90, 802, 45, 75] -> Option C
  4. Quick Check:

    Sort by units digit = [170, 90, 802, 45, 75] [OK]
Hint: Sort by digit at current place only [OK]
Common Mistakes:
  • Sorting entire numbers instead of digits
  • Mixing digit positions
  • Ignoring stable sorting requirement
4. Consider this Java code snippet for Radix Sort digit extraction:
int digit = (num % (int) Math.pow(10, pos)) / (int) Math.pow(10, pos - 1);
What is the error in this code?
medium
A. No error, code works correctly
B. Incorrect order of modulo and division operations
C. Casting to int causes loss of precision
D. Division by zero when pos = 0

Solution

  1. Step 1: Analyze division when pos = 0

    When pos = 0, expression divides by Math.pow(10, -1), which is 10^-1 = 0.1, but casting to int makes it 0, causing division by zero error.
  2. Step 2: Check other options

    Modulo and division order is correct for digit extraction, casting is intentional, so no other errors.
  3. Final Answer:

    Division by zero when pos = 0 -> Option D
  4. Quick Check:

    pos=0 causes division by zero [OK]
Hint: Check division by zero for edge digit positions [OK]
Common Mistakes:
  • Ignoring pos=0 edge case
  • Assuming casting fixes division issues
  • Thinking modulo order is wrong
5. Given the array [329, 457, 657, 839, 436, 720, 355], how many passes (iterations over digits) will Radix Sort perform to fully sort this array?
hard
A. 3 passes
B. 4 passes
C. 2 passes
D. 1 pass

Solution

  1. Step 1: Find the maximum number of digits in the array

    The largest number is 839, which has 3 digits.
  2. Step 2: Determine passes needed

    Radix Sort performs one pass per digit, so 3 passes are needed (units, tens, hundreds).
  3. Final Answer:

    3 passes -> Option A
  4. Quick Check:

    Max digits = 3, passes = 3 [OK]
Hint: Passes = number of digits in largest number [OK]
Common Mistakes:
  • Counting array length instead of digit count
  • Assuming fixed number of passes
  • Ignoring leading zeros in numbers
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard