Count Inversions in Array in DSA Go - Build from Scratch

Count Inversions in Array

📖 Scenario: You are working with a list of numbers representing the order of tasks completed by a team. Sometimes, tasks are done out of the expected order. We want to find out how many such out-of-order pairs (inversions) exist in the list.

🎯 Goal: Build a Go program that counts how many pairs of numbers in an array are out of order. This helps understand how much the order differs from a sorted list.

📋 What You'll Learn

Create a slice of integers named tasks with the exact values: 2, 4, 1, 3, 5

Create an integer variable inversionCount to hold the number of inversions

Write a nested for loop using i and j to compare elements and count inversions

Print the value of inversionCount as the final output

💡 Why This Matters

🌍 Real World

Counting inversions helps measure how far a list is from being sorted, useful in sorting algorithms and analyzing data order.

💼 Career

Understanding inversion counting is important for software engineers working on sorting, data analysis, and performance optimization.

1

Create the tasks slice

Create a slice of integers called tasks with these exact values: 2, 4, 1, 3, 5

DSA Go

package main

func main() {
    // Create the tasks slice with values 2, 4, 1, 3, 5
    // Your code here
}

Hint

Use tasks := []int{2, 4, 1, 3, 5} to create the slice.

2

Create the inversionCount variable

Create an integer variable called inversionCount and set it to 0 inside the main function

DSA Go

package main

func main() {
    tasks := []int{2, 4, 1, 3, 5}
    // Create inversionCount variable and set to 0
    // Your code here
}

Hint

Use inversionCount := 0 to create the counter variable.

3

Count inversions with nested loops

Use nested for loops with variables i and j to compare elements in tasks. Increase inversionCount by 1 whenever tasks[i] is greater than tasks[j] and i < j

DSA Go

package main

func main() {
    tasks := []int{2, 4, 1, 3, 5}
    inversionCount := 0
    // Use nested for loops to count inversions
    // Your code here
}

Hint

Use two loops: outer loop with i from 0 to length-1, inner loop with j from i+1 to length-1. Compare tasks[i] and tasks[j].

4

Print the inversion count

Print the value of inversionCount using fmt.Println(inversionCount) to show the total number of inversions

DSA Go

package main

import "fmt"

func main() {
    tasks := []int{2, 4, 1, 3, 5}
    inversionCount := 0
    for i := 0; i  tasks[j] {
                inversionCount++
            }
        }
    }
    // Print the inversionCount
    // Your code here
}

Hint

Use fmt.Println(inversionCount) to print the result.

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