diff --git a/algorithm_exercises_csharp/src/hackerrank/interview_preparation_kit/arrays/TwoDArray.cs b/algorithm_exercises_csharp/src/hackerrank/interview_preparation_kit/arrays/TwoDArray.cs new file mode 100644 index 0000000..325f196 --- /dev/null +++ b/algorithm_exercises_csharp/src/hackerrank/interview_preparation_kit/arrays/TwoDArray.cs @@ -0,0 +1,65 @@ +namespace algorithm_exercises_csharp.hackerrank.interview_preparation_kit; + +using System.Diagnostics.CodeAnalysis; + +/** + * 2D Array - DS. + * + * @link Problem definition [[docs/hackerrank/interview_preparation_kit/arrays/2d_array.md]] + */ + +public class TwoDArray +{ + [ExcludeFromCodeCoverage] + protected TwoDArray() { } + + private static List getHourGlass(List> arr, int positionX, int positionY) + { + List result = []; + + // top + result.Add(arr[positionX - 1][positionY - 1]); + result.Add(arr[positionX - 1][positionY]); + result.Add(arr[positionX - 1][positionY + 1]); + + // middle + result.Add(arr[positionX][positionY]); + + // bottom + result.Add(arr[positionX + 1][positionY - 1]); + result.Add(arr[positionX + 1][positionY]); + result.Add(arr[positionX + 1][positionY + 1]); + + return result; + } + + public static int hourglassSum(List> arr) + { + int matrixSize = 0; + + if (arr.Count > 0) + { + matrixSize = arr.Count; + } + + int matrixStartIndex = 1; + int matrixEndIndex = matrixSize - 2; + + int? maxHourGlassSum = null; + + for (int i = matrixStartIndex; i <= matrixEndIndex; i++) + { + for (int j = matrixStartIndex; j <= matrixEndIndex; j++) + { + int hourGlassSum = getHourGlass(arr, i, j).Sum(); + + if (maxHourGlassSum == null || hourGlassSum > maxHourGlassSum) + { + maxHourGlassSum = hourGlassSum; + } + } + } + + return maxHourGlassSum ?? 0; + } +} diff --git a/algorithm_exercises_csharp_test/Resources/hackerrank/interview_preparation_kit/arrays/2d_array.testcases.json b/algorithm_exercises_csharp_test/Resources/hackerrank/interview_preparation_kit/arrays/2d_array.testcases.json new file mode 100644 index 0000000..f32bdef --- /dev/null +++ b/algorithm_exercises_csharp_test/Resources/hackerrank/interview_preparation_kit/arrays/2d_array.testcases.json @@ -0,0 +1,14 @@ +[ + { + "title": "Sample Test Case 0", + "input": [ + [1, 1, 1, 0, 0, 0], + [0, 1, 0, 0, 0, 0], + [1, 1, 1, 0, 0, 0], + [0, 0, 2, 4, 4, 0], + [0, 0, 0, 2, 0, 0], + [0, 0, 1, 2, 4, 0] + ], + "expected": 19 + } +] diff --git a/algorithm_exercises_csharp_test/src/hackerrank/interview_preparation_kit/arrays/TwoDArray.Test.cs b/algorithm_exercises_csharp_test/src/hackerrank/interview_preparation_kit/arrays/TwoDArray.Test.cs new file mode 100644 index 0000000..e30d31f --- /dev/null +++ b/algorithm_exercises_csharp_test/src/hackerrank/interview_preparation_kit/arrays/TwoDArray.Test.cs @@ -0,0 +1,35 @@ +namespace algorithm_exercises_csharp.hackerrank.interview_preparation_kit; + +[TestClass] +public class TwoDArrayTest +{ + public class TwoDArrayTestCase + { + public string title { get; set; } = default!; + public List> input { get; set; } = default!; + public long expected { get; set; } = default!; + } + + private List testCases { get; set; } = default!; + + [TestInitialize] + public void testInitialize() + { + testCases = JsonLoader.resourceLoad>( + "hackerrank/interview_preparation_kit/arrays/2d_array.testcases.json" + ) ?? []; + } + + [TestMethod] + public void testHourglassSum() + { + long result; + + foreach (TwoDArrayTestCase test in testCases) + { + result = TwoDArray.hourglassSum(test.input); + Assert.AreEqual(test.expected, result); + } + } +} + diff --git a/docs/hackerrank/interview_preparation_kit/arrays/2d_array.md b/docs/hackerrank/interview_preparation_kit/arrays/2d_array.md new file mode 100644 index 0000000..9c92ffe --- /dev/null +++ b/docs/hackerrank/interview_preparation_kit/arrays/2d_array.md @@ -0,0 +1,135 @@ +# [Arrays: 2D Array - DS](https://www.hackerrank.com/challenges/2d-array) + +- Difficulty: ` #easy ` +- Category: ` #ProblemSolvingBasic ` + +Given a 6 × 6 2D Array, `arr`: + +```text +1 1 1 0 0 0 +0 1 0 0 0 0 +1 1 1 0 0 0 +0 0 0 0 0 0 +0 0 0 0 0 0 +0 0 0 0 0 0 +``` + +An hourglass in `A` is a subset of values with indices falling in this pattern + in `arr`'s graphical representation: + +```text +a b c + d +e f g +``` + +There are `16` hourglasses in `arr`. +An hourglass sum is the sum of an hourglass' values. +Calculate the hourglass sum for every hourglass in `arr`, +then print the maximum hourglass sum. The array will always be 6 × 6. + +## Example + +arr = + +```text +-9 -9 -9 1 1 1 + 0 -9 0 4 3 2 +-9 -9 -9 1 2 3 + 0 0 8 6 6 0 + 0 0 0 -2 0 0 + 0 0 1 2 4 0 +``` + +The `16` hourglass sums are: + +```text +-63, -34, -9, 12, +-10, 0, 28, 23, +-27, -11, -2, 10, + 9, 17, 25, 18 +``` + +The highest hourglass sum is `26` from the hourglass beginning +at row `1`, column `2`: + +```text +0 4 3 + 1 +8 6 6 +```` + +**Note**: If you have already solved the Java domain's Java 2D Array challenge, +you may wish to skip this challenge. + +## Function Description + +Complete the function hourglassSum in the editor below. + +hourglassSum has the following parameter(s): + +- `int arr[6][6]`: an array of integers + +## Returns + +- int: the maximum hourglass sum + +## Input Format + +Each of the `6` lines of inputs `arr[i]` contains space-separated integers `arr[i][j]`. + +## Constraints + +- $9 \leq arr[i][j] \leq 9$ +- $0 \leq i, j \leq 5$ + +## Output Format + +Print the largest (maximum) hourglass sum found in `arr`. + +## Sample Input + +```text +1 1 1 0 0 0 +0 1 0 0 0 0 +1 1 1 0 0 0 +0 0 2 4 4 0 +0 0 0 2 0 0 +0 0 1 2 4 0 +``` + +## Sample Output + +```text +19 +``` + +## Explanation + +`arr` contains the following hourglasses: + +```text +111 110 100 000 + 1 0 0 0 +111 110 100 000 + +010 100 000 000 + 0 1 0 0 +002 024 244 440 + +111 110 100 000 + 0 2 4 4 +000 002 020 200 + +002 024 244 440 + 0 0 2 0 +001 012 124 240 +``` + +The hourglass with the maximum sum (`19`) is: + +```text +2 4 4 + 2 +1 2 4 +```