Add saddle-points exercise (#512)

Author: keiravillekode

config.json

@@ -1003,6 +1003,14 @@
         "prerequisites": [],
         "difficulty": 5
       },
+      {
+        "slug": "saddle-points",
+        "name": "Saddle Points",
+        "uuid": "f4028015-f47c-4826-9f19-814f452a27ce",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 5
+      },
       {
         "slug": "spiral-matrix",
         "name": "Spiral Matrix",

exercises/practice/saddle-points/.docs/instructions.md

@@ -0,0 +1,27 @@
+# Instructions
+
+Your task is to find the potential trees where you could build your tree house.
+
+The data company provides the data as grids that show the heights of the trees.
+The rows of the grid represent the east-west direction, and the columns represent the north-south direction.
+
+An acceptable tree will be the largest in its row, while being the smallest in its column.
+
+A grid might not have any good trees at all.
+Or it might have one, or even several.
+
+Here is a grid that has exactly one candidate tree.
+
+```text
+      ↓
+      1  2  3  4
+    |-----------
+  1 | 9  8  7  8
+→ 2 |[5] 3  2  4
+  3 | 6  6  7  1
+```
+
+- Row 2 has values 5, 3, 2, and 4. The largest value is 5.
+- Column 1 has values 9, 5, and 6. The smallest value is 5.
+
+So the point at `[2, 1]` (row: 2, column: 1) is a great spot for a tree house.

exercises/practice/saddle-points/.docs/introduction.md

@@ -0,0 +1,11 @@
+# Introduction
+
+You plan to build a tree house in the woods near your house so that you can watch the sun rise and set.
+
+You've obtained data from a local survey company that show the height of every tree in each rectangular section of the map.
+You need to analyze each grid on the map to find good trees for your tree house.
+
+A good tree is both:
+
+- taller than every tree to the east and west, so that you have the best possible view of the sunrises and sunsets.
+- shorter than every tree to the north and south, to minimize the amount of tree climbing.

exercises/practice/saddle-points/.meta/config.json

@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "keiravillekode"
+  ],
+  "files": {
+    "solution": [
+      "saddle_points.zig"
+    ],
+    "test": [
+      "test_saddle_points.zig"
+    ],
+    "example": [
+      ".meta/example.zig"
+    ]
+  },
+  "blurb": "Detect saddle points in a matrix.",
+  "source": "J Dalbey's Programming Practice problems",
+  "source_url": "https://users.csc.calpoly.edu/~jdalbey/103/Projects/ProgrammingPractice.html"
+}

exercises/practice/saddle-points/.meta/example.zig

@@ -0,0 +1,53 @@
+const std = @import("std");
+const math = std.math;
+const mem = std.mem;
+
+pub const Point = struct {
+    row: u16,
+    column: u16,
+};
+
+pub fn saddlePoints(comptime m: usize, comptime n: usize, allocator: mem.Allocator, matrix: [m][n]i32) mem.Allocator.Error![]Point {
+    var results = std.array_list.Managed(Point).init(allocator);
+    defer results.deinit();
+
+    if (m == 0 or n == 0) {
+        return results.toOwnedSlice();
+    }
+
+    var tallest = try allocator.alloc(i32, m);
+    defer allocator.free(tallest);
+    for (0..m) |i| {
+        var best: i32 = math.minInt(i32);
+        for (0..n) |j| {
+            if (best < matrix[i][j]) {
+                best = matrix[i][j];
+            }
+        }
+        tallest[i] = best;
+    }
+
+    var shortest = try allocator.alloc(i32, n);
+    defer allocator.free(shortest);
+    for (0..n) |j| {
+        var best: i32 = math.maxInt(i32);
+        for (0..m) |i| {
+            if (best > matrix[i][j]) {
+                best = matrix[i][j];
+            }
+        }
+        shortest[j] = best;
+    }
+
+    for (0..m) |i| {
+        for (0..n) |j| {
+            if (matrix[i][j] == tallest[i] and matrix[i][j] == shortest[j]) {
+                try results.append(.{
+                    .row = @as(u16, @intCast(i + 1)), //
+                    .column = @as(u16, @intCast(j + 1)), //
+                });
+            }
+        }
+    }
+    return results.toOwnedSlice();
+}

exercises/practice/saddle-points/.meta/tests.toml

@@ -0,0 +1,37 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[3e374e63-a2e0-4530-a39a-d53c560382bd]
+description = "Can identify single saddle point"
+
+[6b501e2b-6c1f-491f-b1bb-7f278f760534]
+description = "Can identify that empty matrix has no saddle points"
+
+[8c27cc64-e573-4fcb-a099-f0ae863fb02f]
+description = "Can identify lack of saddle points when there are none"
+
+[6d1399bd-e105-40fd-a2c9-c6609507d7a3]
+description = "Can identify multiple saddle points in a column"
+
+[3e81dce9-53b3-44e6-bf26-e328885fd5d1]
+description = "Can identify multiple saddle points in a row"
+
+[88868621-b6f4-4837-bb8b-3fad8b25d46b]
+description = "Can identify saddle point in bottom right corner"
+
+[5b9499ca-fcea-4195-830a-9c4584a0ee79]
+description = "Can identify saddle points in a non square matrix"
+
+[ee99ccd2-a1f1-4283-ad39-f8c70f0cf594]
+description = "Can identify that saddle points in a single column matrix are those with the minimum value"
+
+[63abf709-a84b-407f-a1b3-456638689713]
+description = "Can identify that saddle points in a single row matrix are those with the maximum value"

exercises/practice/saddle-points/saddle_points.zig

@@ -0,0 +1,13 @@
+const std = @import("std");
+const mem = std.mem;
+
+pub const Point = struct {
+    row: u16,
+    column: u16,
+};
+
+pub fn saddlePoints(comptime m: usize, comptime n: usize, allocator: mem.Allocator, matrix: [m][n]i32) mem.Allocator.Error![]Point {
+    _ = allocator;
+    _ = matrix;
+    @compileError("please implement the saddlePoints function");
+}

exercises/practice/saddle-points/test_saddle_points.zig

@@ -0,0 +1,131 @@
+const std = @import("std");
+const testing = std.testing;
+
+const saddle_points = @import("saddle_points.zig");
+const saddlePoints = saddle_points.saddlePoints;
+const Point = saddle_points.Point;
+
+test "Can identify single saddle point" {
+    const matrix = [3][3]i32{
+        [3]i32{ 9, 8, 7 }, //
+        [3]i32{ 5, 3, 2 }, //
+        [3]i32{ 6, 6, 7 }, //
+    };
+    const expected = [_]Point{
+        .{ .row = 2, .column = 1 }, //
+    };
+    const actual = try saddlePoints(3, 3, testing.allocator, matrix);
+    defer testing.allocator.free(actual);
+    try testing.expectEqualSlices(Point, &expected, actual);
+}
+
+test "Can identify that empty matrix has no saddle points" {
+    const matrix = [1][0]i32{
+        [0]i32{}, //
+    };
+    const expected = [_]Point{};
+    const actual = try saddlePoints(1, 0, testing.allocator, matrix);
+    defer testing.allocator.free(actual);
+    try testing.expectEqualSlices(Point, &expected, actual);
+}
+
+test "Can identify lack of saddle points when there are none" {
+    const matrix = [3][3]i32{
+        [3]i32{ 1, 2, 3 }, //
+        [3]i32{ 3, 1, 2 }, //
+        [3]i32{ 2, 3, 1 }, //
+    };
+    const expected = [_]Point{};
+    const actual = try saddlePoints(3, 3, testing.allocator, matrix);
+    defer testing.allocator.free(actual);
+    try testing.expectEqualSlices(Point, &expected, actual);
+}
+
+test "Can identify multiple saddle points in a column" {
+    const matrix = [3][3]i32{
+        [3]i32{ 4, 5, 4 }, //
+        [3]i32{ 3, 5, 5 }, //
+        [3]i32{ 1, 5, 4 }, //
+    };
+    const expected = [_]Point{
+        .{ .row = 1, .column = 2 }, //
+        .{ .row = 2, .column = 2 }, //
+        .{ .row = 3, .column = 2 }, //
+    };
+    const actual = try saddlePoints(3, 3, testing.allocator, matrix);
+    defer testing.allocator.free(actual);
+    try testing.expectEqualSlices(Point, &expected, actual);
+}
+
+test "Can identify multiple saddle points in a row" {
+    const matrix = [3][3]i32{
+        [3]i32{ 6, 7, 8 }, //
+        [3]i32{ 5, 5, 5 }, //
+        [3]i32{ 7, 5, 6 }, //
+    };
+    const expected = [_]Point{
+        .{ .row = 2, .column = 1 }, //
+        .{ .row = 2, .column = 2 }, //
+        .{ .row = 2, .column = 3 }, //
+    };
+    const actual = try saddlePoints(3, 3, testing.allocator, matrix);
+    defer testing.allocator.free(actual);
+    try testing.expectEqualSlices(Point, &expected, actual);
+}
+
+test "Can identify saddle point in bottom right corner" {
+    const matrix = [3][3]i32{
+        [3]i32{ 8, 7, 9 }, //
+        [3]i32{ 6, 7, 6 }, //
+        [3]i32{ 3, 2, 5 }, //
+    };
+    const expected = [_]Point{
+        .{ .row = 3, .column = 3 }, //
+    };
+    const actual = try saddlePoints(3, 3, testing.allocator, matrix);
+    defer testing.allocator.free(actual);
+    try testing.expectEqualSlices(Point, &expected, actual);
+}
+
+test "Can identify saddle points in a non square matrix" {
+    const matrix = [2][3]i32{
+        [3]i32{ 3, 1, 3 }, //
+        [3]i32{ 3, 2, 4 }, //
+    };
+    const expected = [_]Point{
+        .{ .row = 1, .column = 1 }, //
+        .{ .row = 1, .column = 3 }, //
+    };
+    const actual = try saddlePoints(2, 3, testing.allocator, matrix);
+    defer testing.allocator.free(actual);
+    try testing.expectEqualSlices(Point, &expected, actual);
+}
+
+test "Can identify that saddle points in a single column matrix are those with the minimum value" {
+    const matrix = [4][1]i32{
+        [1]i32{2}, //
+        [1]i32{1}, //
+        [1]i32{4}, //
+        [1]i32{1}, //
+    };
+    const expected = [_]Point{
+        .{ .row = 2, .column = 1 }, //
+        .{ .row = 4, .column = 1 }, //
+    };
+    const actual = try saddlePoints(4, 1, testing.allocator, matrix);
+    defer testing.allocator.free(actual);
+    try testing.expectEqualSlices(Point, &expected, actual);
+}
+
+test "Can identify that saddle points in a single row matrix are those with the maximum value" {
+    const matrix = [1][4]i32{
+        [4]i32{ 2, 5, 3, 5 }, //
+    };
+    const expected = [_]Point{
+        .{ .row = 1, .column = 2 }, //
+        .{ .row = 1, .column = 4 }, //
+    };
+    const actual = try saddlePoints(1, 4, testing.allocator, matrix);
+    defer testing.allocator.free(actual);
+    try testing.expectEqualSlices(Point, &expected, actual);
+}