8) matrix elements sum

Author: Jakub Jirous

src/arcade/intro/01-add/test/add.test.ts

@@ -2,9 +2,6 @@ import { add, Output, Param1, Param2 } from '../add';
 
 type Cases = [Param1, Param2, Output][];
 
-/**
- * Testing a function that returns the sum of two numbers.
- */
 describe("Add", () => {
   const cases: Cases = [
     [1, 2, 3],

src/arcade/intro/02-century-from-year/INDEX.md

@@ -8,8 +8,8 @@ The first century spans from the year 1 up to and including the year 100, the se
 
 ### Example:
 
-- For `year = 1905`, the output should be `centuryFromYear(year) = 20`
-- For `year = 1700`, the output should be `centuryFromYear(year) = 17`
+- For `year = 1905`, the output should be `centuryFromYear(year) = 20`.
+- For `year = 1700`, the output should be `centuryFromYear(year) = 17`.
 
 ### Input/Output:
 

src/arcade/intro/02-century-from-year/test/century-from-year.test.ts

@@ -2,9 +2,6 @@ import { centuryFromYear, Input, Output } from '../century-from-year';
 
 type Cases = [Input, Output][];
 
-/**
- * Given a year, return the century it is in.
- */
 describe("Century From Year", () => {
   const cases: Cases = [
     [1905, 20],

src/arcade/intro/03-check-palindrome/INDEX.md

@@ -6,9 +6,9 @@ Given the string, check if it is a palindrome.
 
 ### Example:
 
-- For `inputString = "aabaa"`, the output should be `checkPalindrome(inputString) = true`
-- For `inputString = "abac"`, the output should be `checkPalindrome(inputString) = false`
-- For `inputString = "a"`, the output should be `checkPalindrome(inputString) = true`
+- For `inputString = "aabaa"`, the output should be `checkPalindrome(inputString) = true`.
+- For `inputString = "abac"`, the output should be `checkPalindrome(inputString) = false`.
+- For `inputString = "a"`, the output should be `checkPalindrome(inputString) = true`.
 
 ### Input/Output:
 

src/arcade/intro/03-check-palindrome/test/check-palindrome.test.ts

@@ -2,9 +2,6 @@ import { checkPalindrome, Input, Output } from '../check-palindrome';
 
 type Cases = [Input, Output][];
 
-/**
- * Test if it is a palindrome.
- */
 describe("Check Palindrome", () => {
   const cases: Cases = [
     ["aabaa", true],

src/arcade/intro/04-adjacent-elements-product/test/adjacent-elements-product.test.ts

@@ -2,9 +2,6 @@ import { adjacentElementsProduct, Input, Output } from '../adjacent-elements-pro
 
 type Cases = [Input, Output][];
 
-/**
- * Given an array of integers, test the pair of adjacent elements that has the largest product and return that product.
- */
 describe("Adjacent Elements Product", () => {
   const cases: Cases = [
     [[3, 6, -2, -5, 7, 3], 21],

src/arcade/intro/05-shape-area/INDEX.md

@@ -11,8 +11,8 @@ An `n`-interesting polygon is obtained by taking the `n - 1`-interesting polygon
 
 ### Example:
 
-- For `n = 2`, the output should be `shapeArea(n) = 5`
-- For `n = 3`, the output should be `shapeArea(n) = 13`
+- For `n = 2`, the output should be `shapeArea(n) = 5`.
+- For `n = 3`, the output should be `shapeArea(n) = 13`.
 
 ### Input/Output:
 

src/arcade/intro/05-shape-area/test/shape-area.test.ts

@@ -2,9 +2,6 @@ import { Input, Output, shapeArea } from '../shape-area';
 
 type Cases = [Input, Output][];
 
-/**
- * Test the area of a polygon for a given n.
- */
 describe("Shape Area", () => {
   const cases: Cases = [
     [2, 5],

src/arcade/intro/06-make-array-consecutive/test/make-array-consecutive.test.ts

@@ -2,9 +2,6 @@ import { Input, makeArrayConsecutive, Output } from '../make-array-consecutive';
 
 type Cases = [Input, Output][];
 
-/**
- * Tests the minimal number of statues that need to be added to existing statues such that it contains every integer size from an interval [L, R] (for some L, R) and no other sizes.
- */
 describe("Make Array Consecutive", () => {
   const cases: Cases = [
     [[6, 2, 3, 8], 3],

src/arcade/intro/07-almost-increasing-sequence/INDEX.md

@@ -10,11 +10,11 @@ Given a sequence of integers as an array, determine whether it is possible to ob
 
 ### Example:
 
-- For `sequence = [1, 3, 2, 1]`, the output should be `almostIncreasingSequence(sequence) = false`
+- For `sequence = [1, 3, 2, 1]`, the output should be `almostIncreasingSequence(sequence) = false`.
   - There is no one element in this array that can be removed in order to get a strictly increasing sequence.
 
 
-- For `sequence = [1, 3, 2]`, the output should be `almostIncreasingSequence(sequence) = true`
+- For `sequence = [1, 3, 2]`, the output should be `almostIncreasingSequence(sequence) = true`.
   - You can remove `3` from the array to get the strictly increasing sequence `[1, 2]`. 
   - Alternately, you can remove `2` to get the strictly increasing sequence `[1, 3]`. 
 
@@ -31,11 +31,11 @@ Given a sequence of integers as an array, determine whether it is possible to ob
 
 - **[output]** boolean
   - Return `true` if it is possible to remove one element from the array in order to get a strictly increasing sequence.
-  - Otherwise return `false`.
+  - Otherwise, return `false`.
 
 ---
 
 ### Solution:
 
-- [Code](/src/arcade/intro/06-make-array-consecutive/make-array-consecutive.ts)
-- [Tests](/src/arcade/intro/06-make-array-consecutive/test/make-array-consecutive.test.ts)
+- [Code](/src/arcade/intro/07-almost-increasing-sequence/almost-increasing-sequence.ts)
+- [Tests](/src/arcade/intro/07-almost-increasing-sequence/test/almost-increasing-sequence.test.ts)

src/arcade/intro/07-almost-increasing-sequence/test/almost-increasing-sequence.test.ts

@@ -2,9 +2,6 @@ import { almostIncreasingSequence, Input, Output } from '../almost-increasing-se
 
 type Cases = [Input, Output][];
 
-/**
- * Tests whether it is possible to obtain a strictly increasing sequence by removing no more than one element from the array.
- */
 describe("Almost Increasing Sequence", () => {
   const cases: Cases = [
     [[1, 3, 2, 1], false],

src/arcade/intro/08-matrix-elements-sum/INDEX.md

@@ -0,0 +1,61 @@
+# Matrix Elements Sum
+
+After becoming famous, the CodeBots decided to move into a new building together. 
+
+Each of the rooms has a different cost, and some of them are free, but there's a rumour that all the free rooms are haunted! Since the CodeBots are quite superstitious, they refuse to stay in any of the free rooms, or any of the rooms below any of the free rooms.
+
+Given `matrix`, a rectangular matrix of integers, where each value represents the cost of the room, your task is to return the total sum of all rooms that are suitable for the CodeBots (ie: add up all the values that don't appear below a `0`).
+
+---
+
+### Example:
+
+- For `matrix`:
+  - ```
+    [
+      [0, 1, 1, 2], 
+      [0, 5, 0, 0], 
+      [2, 0, 3, 3]
+    ]
+    ```
+  - The output should be `matrixElementsSum(matrix) = 9` .
+  - There are several haunted rooms, so we'll disregard them as well as any rooms beneath them.
+  - Thus, the answer is `1 + 5 + 1 + 2 = 9`.
+
+
+- For `matrix`:
+  - ```
+    [
+      [1, 1, 1, 0], 
+      [0, 5, 0, 1], 
+      [2, 1, 3, 10]
+    ]
+    ```
+  - The output should be `matrixElementsSum(matrix) = 9`.
+  - The free room in the final column makes the full column unsuitable for bots (not just the room directly beneath it). 
+  - Thus, the answer is `1 + 1 + 1 + 5 + 1 = 9`.
+
+
+### Input/Output:
+
+- **[execution time limit]** 5 seconds (ts)
+
+
+- **[input]** array.array.integer `matrix`
+  - A 2-dimensional array of integers representing the cost of each room in the building. 
+  - A value of `0` indicates that the room is haunted. 
+  - Guaranteed constraints:
+    - $1 \le matrix.length \le 5}$
+    - $1 \le matrix[i].length \le 5}$
+    - $0 \le matrix[i][j] \le 10$
+ 
+
+- **[output]** integer
+  - The total price of all the rooms that are suitable for the CodeBots to live in.
+
+---
+
+### Solution:
+
+- [Code](/src/arcade/intro/08-matrix-elements-sum/matrix-elements-sum.ts)
+- [Tests](/src/arcade/intro/08-matrix-elements-sum/test/matrix-elements-sum.test.ts)

src/arcade/intro/08-matrix-elements-sum/matrix-elements-sum.ts

@@ -0,0 +1,29 @@
+export type Input = number[][];
+export type Output = number;
+
+/**
+ * After becoming famous, the CodeBots decided to move into a new building together.
+ * Each of the rooms has a different cost, and some of them are free, but there's a rumour that all the free rooms are haunted! Since the CodeBots are quite superstitious, they refuse to stay in any of the free rooms, or any of the rooms below any of the free rooms.
+ *
+ * @param matrix
+ */
+export const matrixElementsSum = (matrix: Input): Output => {
+  let ghosts: number[] = [];
+  let cost = 0;
+
+  for (let i = 0; i < matrix.length; i++) {
+    for (let j = 0; j < matrix[i].length; j++) {
+      const val = matrix[i][j];
+
+      if (val === 0) {
+        ghosts.push(j);
+      }
+
+      if (val !== 0 && !ghosts.includes(j)) {
+        cost += val;
+      }
+    }
+  }
+
+  return cost;
+};

src/arcade/intro/08-matrix-elements-sum/test/matrix-elements-sum.test.ts

@@ -0,0 +1,62 @@
+import { matrixElementsSum, Input, Output } from "../matrix-elements-sum";
+
+type Cases = [Input, Output][];
+
+describe("Matrix Elements Sum", () => {
+  const cases: Cases = [
+    [
+      [
+        [0, 1, 1, 2],
+        [0, 5, 0, 0],
+        [2, 0, 3, 3],
+      ],
+      9,
+    ],
+    [
+      [
+        [1, 1, 1, 0],
+        [0, 5, 0, 1],
+        [2, 1, 3, 10],
+      ],
+      9,
+    ],
+    [
+      [
+        [1, 1, 1],
+        [2, 2, 2],
+        [3, 3, 3],
+      ],
+      18,
+    ],
+    [[[0]], 0],
+    [[[1], [5], [0], [2]], 6],
+    [[[1, 2, 3, 4, 5]], 15],
+    [
+      [
+        [1, 0, 3],
+        [0, 2, 1],
+        [1, 2, 0],
+      ],
+      5,
+    ],
+    [[[2], [5], [10]], 17],
+    [
+      [
+        [4, 0, 1],
+        [10, 7, 0],
+        [0, 0, 0],
+        [9, 1, 2],
+      ],
+      15,
+    ],
+    [[[1]], 1],
+  ];
+
+  test.each(cases)(
+    "for matrix %j output should be %d",
+    (firstArg, expectedResult) => {
+      const result = matrixElementsSum(firstArg);
+      expect(result).toEqual(expectedResult);
+    }
+  );
+});