Hi there! Today’s post is not from HackerRank. This was an assignment that I solved for the *Algorithms: Design and Analysis, Part 1* course from Coursera. The goal is to implement an algorithm presented in the videos. It was explained in high level and not considering edge cases. I first tried to do it in `C++`

but it was taking me more time than I wanted to spend and then I switched to `Go`

and it was blazing fast to code. What really helped me to solve it fast was the idea of a `slice`

in `Go`

. Slices can be partitioned easily. For instance

`P := a[:m]`

,`P`

is a slice with all elements up to index`m`

exclusively from`a`

`Q := a[m:]`

,`Q`

is a slice with all elements from index`m`

inclusively to the end of`a`

In `C++`

, the above operations would require me more lines of code. I would need to check the end of my vector `a`

, declare two new `vector<int>`

`P`

and `Q`

and then add half of the elements in each newly allocated vector using a `for`

loop.

The assignment required to me to count the inversions of a given unordered list. Below is an example.

```
input = [6, 5, 4, 3, 2, 1]
# list after sorting
output = [1, 2, 3, 4, 5, 6]
# number of inversions found
inversions = 15
```

The number of inversions is maximum when the list is in reverse order like the example above. When we look at 6, we see there are five elements out of order after it. Then looking at 5 we see four elements out of order after it. In the end, we count 5+4+3+2+1 = 15 inversions for the example. The formula for the maximum number of inversions in a list of integers of size `$n$`

is `$$f(n) = \left(\begin{array}{c}n\\ 2\end{array}\right) = \frac{n(n-1)}{2}.$$`

My solution is presented below and it requires the first input to be `N`

, the number of integers that will be fed to the program, and then the `N`

integers need to be separated by `\n`

. I just did that because the input they gave me was a text file with all numbers separated by `\n`

.

```
package main
import (
"fmt"
"math"
)
// result is the merged list and the
// number of inversions
func merge(a []int, b []int, n0 int) ([]int, int) {
n := 0 // number of inversions
m := len(a) + len(b)
result := make([]int, m)
i := 0
j := 0
// print(b)
for k := 0; k < m; k++ {
// --- edge cases -----
if i == len(a) {
result[k] = b[j]
j++
continue
}
if j == len(b) {
result[k] = a[i]
i++
continue
}
// -- general cases --
if a[i] < b[j] {
result[k] = a[i]
i++
} else {
result[k] = b[j]
j++
// add number of inversions
// for current merging
n += len(a) - i
}
}
return result, n + n0
}
func merge_sort(a []int) ([]int, int) {
n := 0
if len(a) > 1 {
// divide and call merge sort
m := int(math.Ceil(float64(len(a)) / 2.0))
P := a[:m]
Q := a[m:]
result1, n1 := merge_sort(P)
result2, n2 := merge_sort(Q)
return merge(result1, result2, n1+n2)
}
return a, n
}
func main() {
// Input file has N
// in the first line
// indicating how many
// lines the file has
N := 0
fmt.Scanf("%d\n", &N)
// allocate memory
X := make([]int, N)
for i := 0; i < N; i++ {
fmt.Scanf("%d\n", &X[i])
}
// Ignore sorted list,
// if needed just change _
// by a name
_, n := merge_sort(X)
fmt.Printf("#Inversions: %d\n", n)
}
```

Running

```
$ go build merge_sort.go
$ ./merge_sort < IntegerArray.txt
#Inversions: 2407905288
```

The main difficulties I had were the edge cases. They were not presented in class and I was having weird bugs saying I was trying to access an out of bounds element of the slice.

That’s all for this assignment, thanks for reading!