[Hacker Rank] Interview Preparation Kit: Arrays: Array Manipulation. Solved ✅. Optimized solution.

Author: Gonzalo Diaz

docs/hackerrank/interview_preparation_kit/arrays/crush_optimized-solution-notes.md

@@ -0,0 +1,37 @@
+# [Array Manipulation](https://www.hackerrank.com/challenges/crush)
+
+Perform m operations on an array and print the maximum of the values.
+
+- Difficulty:  ` #hard `
+- Category: ` #ProblemSolvingIntermediate `
+
+## Solution sources
+
+### Brute force idea
+
+The first solution attempt is based on the idea of going through:
+
+> each row and then,
+> > each sub-set of elements affected by the operation.
+
+With this principle, the algorithm becomes O(N^2)
+
+### Optimized
+
+Reading about posible optimizations,
+I found the possibility of summarizing the interior traversal with
+addition operations for each element in each row of operations,
+in only 2 constant operations, which represents the necessary values so that
+in a single final traversal, the sum values can be obtained "by drag".
+The algorithm is called "prefix sum."
+
+Some sources about "prefix sum"
+
+- <https://hmn.wiki/en/Prefix_sum>
+- <https://en.wikipedia.org/wiki/Prefix_sum>
+- <https://usaco.guide/silver/prefix-sums?lang=py>
+
+Some sources about implementation in:
+
+- [HackerRank Array Manipulation — beat the clock using Prefix Sum (JavaScript)](https://medium.com/@mlgerardvla/hackerrank-array-manipulation-beat-the-clock-using-prefix-sum-92471060035e)
+- [Hackerrank Discussions Forums: Array Manipulation](https://www.hackerrank.com/challenges/one-month-preparation-kit-crush/forum)

exercises/hackerrank/interview_preparation_kit/arrays/crush.go

@@ -0,0 +1,47 @@
+/**
+ * @link Problem definition [[docs/hackerrank/interview_preparation_kit/2d_array.md]]
+ */
+
+package hackerrank
+
+func arrayManipulation(n int32, queries [][]int32) int64 {
+	// why adding 2?
+	//   first slot to adjust 1-based index and
+	//   last slot for storing accumSum result
+	var LENGTH int32 = n + 2
+	const InitialValue int64 = 0
+	var maximum int64 = 0
+
+	result := make([]int64, LENGTH)
+	for i := 0; int32(i) < LENGTH; i++ {
+		result[i] = InitialValue
+	}
+
+	var aStart int32
+	var bEnd int32
+	var kValue int32
+
+	for _, query_row := range queries {
+		aStart = query_row[0]
+		bEnd = query_row[1]
+		kValue = query_row[2]
+
+		result[aStart] += int64(kValue)
+		result[bEnd+1] -= int64(kValue)
+	}
+
+	var accumSum int64 = 0
+
+	for _, value := range result {
+		accumSum += value
+		if accumSum > maximum {
+			maximum = accumSum
+		}
+	}
+
+	return maximum
+}
+
+func ArrayManipulation(n int32, queries [][]int32) int64 {
+	return arrayManipulation(n, queries)
+}

exercises/hackerrank/interview_preparation_kit/arrays/crush_test.go

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