Count Inversions in Array in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the inversion count variable.

DSA Go

func countInversions(arr []int) int {
    inversions := [1]
    // rest of the code
    return inversions
}

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

A1

Blen(arr)

C0

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing inversions to 1 or length of array instead of 0.

We start counting inversions from zero because initially, no pairs are counted.

2fill in blank

medium

Complete the code to compare elements for inversion detection.

DSA Go

for i := 0; i < len(arr); i++ {
    for j := i + 1; j < len(arr); j++ {
        if arr[i] [1] arr[j] {
            inversions++
        }
    }
}

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

A>

B!=

C==

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>' to compare elements.

An inversion is when a larger element appears before a smaller one, so arr[i] > arr[j].

3fill in blank

hard

Fix the error in the merge function to count cross inversions correctly.

DSA Go

func merge(arr []int, temp []int, left, mid, right int) int {
    i, j, k := left, mid+1, left
    invCount := 0
    for i <= mid && j <= right {
        if arr[i] <= arr[j] {
            temp[k] = arr[i]
            i++
            k++
        } else {
            temp[k] = arr[j]
            invCount += [1]
            j++
            k++
        }
    }
    // rest of merge code
    return invCount
}

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

Aright - j + 1

Bi - mid + 1

Cj - i + 1

Dmid - i + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong indices to count inversions in merge step.

When arr[i] > arr[j], all elements from i to mid form inversions with arr[j].

4fill in blank

hard

Fill both blanks to complete the recursive merge sort call and inversion count addition.

DSA Go

func mergeSort(arr []int, temp []int, left, right int) int {
    invCount := 0
    if left < right {
        mid := (left + right) / 2
        invCount += mergeSort(arr, temp, left, [1])
        invCount += mergeSort(arr, temp, [2], right)
        invCount += merge(arr, temp, left, mid, right)
    }
    return invCount
}

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

Amid

Bleft

Cmid + 1

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Using mid+1 for left half or mid for right half incorrectly.

Left half is from left to mid, right half is from mid+1 to right.

5fill in blank

hard

Fill all three blanks to complete the merge function copying remaining elements.

DSA Go

for i <= mid {
    temp[[1]] = arr[[2]]
    i++
    [3]++
}
for j <= right {
    temp[k] = arr[j]
    j++
    k++
}

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

Ak

Bi

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing indices i and k incorrectly while copying.

Copy remaining left elements from arr[i] to temp[k], increment i and k.

Practice

1. What does the term inversion mean in the context of an array?

easy

A. A pair of elements where the first is smaller than the second and appears before it

B. A pair of elements where the first is greater than the second and appears before it

C. The total number of elements in the array

D. The sum of all elements in the array

Solution

1. Step 1: Understand the definition of inversion

   An inversion is a pair of elements (i, j) such that i < j but array[i] > array[j].

2. Step 2: Identify the correct description

   A pair of elements where the first is greater than the second and appears before it correctly describes this condition as the first element being greater and appearing before the second.

3. Final Answer:

   A -> Option B

4. Quick Check:

   Inversion = pair where first > second and first appears earlier [OK]

Hint: Inversion means earlier element is bigger than a later one [OK]

Common Mistakes:

• Confusing inversion with sorted order
• Thinking inversion counts equal or smaller pairs
• Mixing up element positions

2. Which of the following Go code snippets correctly declares a function to count inversions in an integer slice?

easy

A. func countInversions(arr []int) int { return 0 }

B. func countInversions(arr int[]) int { return 0 }

C. func countInversions(arr []int) void { return 0 }

D. func countInversions(arr []int) int { return "0" }

Solution

1. Step 1: Check function signature syntax in Go

   In Go, a function with an integer slice parameter and integer return type is declared as func name(arr []int) int.

2. Step 2: Validate return statement type

   func countInversions(arr []int) int { return 0 } returns an integer 0, matching the return type. Other options have syntax errors or wrong return types.

3. Final Answer:

   C -> Option A

4. Quick Check:

   Correct Go function syntax returns int [OK]

Hint: Go slices use []int, return type after params [OK]

Common Mistakes:

• Using wrong slice syntax like int[]
• Returning wrong type like string instead of int
• Using void instead of int for return type

3. What is the output of the following Go code snippet?

func main() {
    arr := []int{2, 4, 1, 3, 5}
    fmt.Println(countInversions(arr))
}

func countInversions(arr []int) int {
    count := 0
    for i := 0; i < len(arr); i++ {
        for j := i + 1; j < len(arr); j++ {
            if arr[i] > arr[j] {
                count++
            }
        }
    }
    return count
}

medium

A. 4

B. 5

C. 2

D. 3

Solution

1. Step 1: Identify all inversion pairs in the array

   Array: [2, 4, 1, 3, 5]. Inversions are (2,1), (4,1), (4,3). Total = 3.

2. Step 2: Confirm count from nested loops

   Loops check all pairs i

3. Final Answer:

   3 -> Option D

4. Quick Check:

   Inversions counted = 3 [OK]

Hint: Count pairs where earlier number is bigger [OK]

Common Mistakes:

• Counting pairs where first is smaller
• Missing some inversion pairs
• Confusing index order

4. The following Go function is intended to count inversions but has a bug. What is the bug?

func countInversions(arr []int) int {
    count := 0
    for i := 0; i <= len(arr); i++ {
        for j := i + 1; j < len(arr); j++ {
            if arr[i] > arr[j] {
                count++
            }
        }
    }
    return count
}

medium

A. The outer loop uses <= causing index out of range error

B. The inner loop starts from wrong index

C. The comparison operator should be < instead of >

D. The count variable is not initialized

Solution

1. Step 1: Analyze loop boundaries

   The outer loop runs with i <= len(arr), which means i can equal len(arr), causing arr[i] to be out of range.

2. Step 2: Identify correct loop condition

   The loop should use i < len(arr) to avoid accessing invalid index.

3. Final Answer:

   The outer loop uses <= causing index out of range error -> Option A

4. Quick Check:

   Loop index must be less than length [OK]

Hint: Loop index must be less than length, not less or equal [OK]

Common Mistakes:

• Using <= instead of < in loops
• Starting inner loop at wrong index
• Wrong comparison operator

5. Given the array [8, 4, 2, 1], which approach is the most efficient to count inversions and what is the inversion count?

hard

A. Use bubble sort swaps count; inversion count is 4

B. Use brute force nested loops; inversion count is 6

C. Use merge sort based method; inversion count is 6

D. Use quicksort partition count; inversion count is 3

Solution

1. Step 1: Understand efficient inversion counting

   Merge sort based method counts inversions in O(n log n) time, more efficient than brute force O(n²).

2. Step 2: Calculate inversion count for [8,4,2,1]

   Inversions: (8,4), (8,2), (8,1), (4,2), (4,1), (2,1) = 6 total.

3. Final Answer:

   Use merge sort based method; inversion count is 6 -> Option C

4. Quick Check:

   Merge sort counts 6 inversions efficiently [OK]

Hint: Use merge sort for fast inversion count [OK]

Common Mistakes:

• Using slow brute force for large arrays
• Miscounting inversion pairs
• Confusing inversion count with swap count