Merge pull request #313 from sir-gon/feature/minimum_swaps_2

[Hacker Rank] Interview Preparation Kit: Arrays: Minimum Swaps 2. Sol…

Author: sir-gon

docs/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2.md

@@ -0,0 +1,128 @@
+# [Arrays: New Year Chaos](https://www.hackerrank.com/challenges/minimum-swaps-2)
+
+Return the minimum number of swaps to sort the given array.
+
+- Difficulty:  ` #medium `
+- Category: ` #ProblemSolvingIntermediate `
+
+You are given an unordered array consisting of consecutive integers
+[1, 2, 3, ..., n] without any duplicates. You are allowed to swap any
+two elements. Find the minimum number of swaps required to sort the
+array in ascending order.
+
+## Example
+
+` arr = [7, 1, 3, 2, 4, 5, 6] `
+
+Perform the following steps:
+
+```text
+i   arr                     swap (indices)
+0   [7, 1, 3, 2, 4, 5, 6]   swap (0,3)
+1   [2, 1, 3, 7, 4, 5, 6]   swap (0,1)
+2   [1, 2, 3, 7, 4, 5, 6]   swap (3,4)
+3   [1, 2, 3, 4, 7, 5, 6]   swap (4,5)
+4   [1, 2, 3, 4, 5, 7, 6]   swap (5,6)
+5   [1, 2, 3, 4, 5, 6, 7]
+```
+
+It took `5` swaps to sort the array.
+
+## Function Description
+
+Complete the function minimumSwaps in the editor below.
+
+minimumSwaps has the following parameter(s):
+
+- `int arr[n]`: an unordered array of integers
+
+## Returns
+
+- `int`: the minimum number of swaps to sort the array
+
+## Input Format
+
+The first line contains an integer, , the size of .
+The second line contains  space-separated integers .
+
+## Constraints
+
+Sample Input 0
+
+- $ 1 \leq n \leq 10^5 $
+- $ 1 \leq arr[i] \leq 10^5 $
+
+## Sample Input 0
+
+```text
+4
+4 3 1 2
+```
+
+## Sample Output 0
+
+```text
+3
+```
+
+## Explanation 0
+
+Given array `arr: [4, 3, 1, 2]`
+
+After swapping `(0, 2)` we get `[1, 3, 4, 2]`
+
+After swapping `(1, 2)` we get `[1, 4, 3, 2]`
+
+After swapping `(1, 3)` we get `[1, 2, 3, 4]`
+
+So, we need a minimum of `3` swaps to sort the array in ascending order.
+
+## Sample Input 1
+
+```text
+5
+2 3 4 1 5
+```
+
+## Sample Output 1
+
+```text
+3
+```
+
+## Explanation 1
+
+Given array `arr: [1, 3, 5, 2, 4, 6, 7]`
+
+After swapping `(1, 3)` we get `[2, 3, 1, 4, 5]`
+
+After swapping `(0, 1)` we get `[3, 2, 1, 4, 5]`
+
+After swapping `(0, 2)` we get `[1, 2, 3, 4, 5]`
+
+So, we need a minimum of `3` swaps to sort the array in ascending order.
+
+## Sample Input 2
+
+```text
+7
+1 3 5 2 4 6 7
+```
+
+## Sample Output 2
+
+```text
+3
+```
+
+## Explanation 2
+
+Given array `[1, 3, 5, 2, 4, 6, 7]`
+
+After swapping `(1, 3)` we get `[1, 2, 5, 3, 4, 6, 7]`
+
+After swapping `(2, 3)` we get `[1, 2, 3, 5, 4, 6, 7]`
+
+After swapping `(3, 4)` we get `[1, 2, 3, 4, 5, 6, 7]`
+
+So, we need a minimum of `3` swaps to sort the array in ascending order.

exercises/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2.go

@@ -0,0 +1,33 @@
+/**
+ * @link Problem definition [[docs/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2.md]]
+ */
+
+package hackerrank
+
+func minimumSwaps(arr []int32) int32 {
+	var size int32 = int32(len(arr))
+	var indexedGroup = make(map[int32]int32, size)
+	var swaps int32 = 0
+	var index int32 = 0
+
+	for key, value := range arr {
+		indexedGroup[int32(key)] = value - 1
+	}
+
+	for index < size {
+		if indexedGroup[index] == index {
+			index += 1
+		} else {
+			var temp = indexedGroup[index]
+			indexedGroup[index] = indexedGroup[temp]
+			indexedGroup[temp] = temp
+			swaps += 1
+		}
+	}
+
+	return swaps
+}
+
+func MinimumSwaps(arr []int32) int32 {
+	return minimumSwaps(arr)
+}

exercises/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2.testcases.json

@@ -0,0 +1,5 @@
+[
+    {"title": "Sample input 0", "input": [4, 3, 1, 2], "expected": 3},
+    {"title": "Sample input 1", "input": [2, 3, 4, 1, 5], "expected": 3},
+    {"title": "Sample input 2", "input": [1, 3, 5, 2, 4, 6, 7], "expected": 3}
+]

exercises/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2_test.go

@@ -0,0 +1,43 @@
+package hackerrank
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"gon.cl/algorithms/utils"
+)
+
+type MinimumTwoSwaps2TestCase struct {
+	Input    []int32 `json:"input"`
+	Expected int32   `json:"expected"`
+}
+
+var MinimumTwoSwaps2testCases []MinimumTwoSwaps2TestCase
+
+// You can use testing.T, if you want to test the code without benchmarking
+func testMinimumTwoSwaps2SetupSuite(t testing.TB) {
+	wd, _ := os.Getwd()
+	filepath := wd + "/minimum_swaps_2.testcases.json"
+	t.Log("Setup test cases from JSON: ", filepath)
+
+	var _, err = utils.LoadJSON(filepath, &MinimumTwoSwaps2testCases)
+	if err != nil {
+		t.Log(err)
+	}
+}
+
+func TestMinimumTwoSwaps2(t *testing.T) {
+
+	testMinimumTwoSwaps2SetupSuite(t)
+
+	for _, tt := range MinimumTwoSwaps2testCases {
+		testname := fmt.Sprintf("MinimumSwaps(%v) => %d \n", tt.Input, tt.Expected)
+		t.Run(testname, func(t *testing.T) {
+			ans := MinimumSwaps(tt.Input)
+			assert.Equal(t, tt.Expected, ans)
+		})
+
+	}
+}