diff --git a/bin/auto-sync.txt b/bin/auto-sync.txt
index 16e02841..e0751909 100644
--- a/bin/auto-sync.txt
+++ b/bin/auto-sync.txt
@@ -72,6 +72,7 @@ robot-simulator
 roman-numerals
 rotational-cipher
 run-length-encoding
+saddle-points
 say
 scrabble-score
 secret-handshake
diff --git a/config.json b/config.json
index 3268f8fc..12574b81 100644
--- a/config.json
+++ b/config.json
@@ -458,6 +458,14 @@
           "strings"
         ]
       },
+      {
+        "slug": "saddle-points",
+        "name": "Saddle Points",
+        "uuid": "5ae50dea-8879-414f-afc8-49db16b53498",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 1
+      },
       {
         "slug": "series",
         "name": "Series",
diff --git a/exercises/practice/saddle-points/.docs/instructions.md b/exercises/practice/saddle-points/.docs/instructions.md
new file mode 100644
index 00000000..f69cdab9
--- /dev/null
+++ b/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.
diff --git a/exercises/practice/saddle-points/.docs/introduction.md b/exercises/practice/saddle-points/.docs/introduction.md
new file mode 100644
index 00000000..34b2c77e
--- /dev/null
+++ b/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.
diff --git a/exercises/practice/saddle-points/.meta/config.json b/exercises/practice/saddle-points/.meta/config.json
new file mode 100644
index 00000000..7fc8ff44
--- /dev/null
+++ b/exercises/practice/saddle-points/.meta/config.json
@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "resu-xuniL"
+  ],
+  "files": {
+    "solution": [
+      "SaddlePoints.php"
+    ],
+    "test": [
+      "SaddlePointsTest.php"
+    ],
+    "example": [
+      ".meta/example.php"
+    ]
+  },
+  "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"
+}
diff --git a/exercises/practice/saddle-points/.meta/example.php b/exercises/practice/saddle-points/.meta/example.php
new file mode 100644
index 00000000..73dfe55c
--- /dev/null
+++ b/exercises/practice/saddle-points/.meta/example.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+class SaddlePoints
+{
+    public function saddlePoints(array $matrix): array
+    {
+        if (empty($matrix[0])) {
+            return [];
+        }
+
+        $trees = [];
+        $maxs  = array_map('max', array_map(null, $matrix));
+
+        if (count($matrix) > 1) {
+            $mins = array_map('min', array_map(null, ...$matrix));
+        } else {
+            $mins = $matrix[0];
+        }
+
+        for ($ridx = 0; $ridx < count($matrix); $ridx++) {
+            for ($cidx = 0; $cidx < count($matrix[$ridx]); $cidx++) {
+                if ($maxs[$ridx] === $mins[$cidx]) {
+                    array_push($trees, [
+                        'row'    => $ridx + 1,
+                        'column' => $cidx + 1
+                    ]);
+                }
+            }
+        }
+
+        return $trees;
+    }
+}
diff --git a/exercises/practice/saddle-points/.meta/tests.toml b/exercises/practice/saddle-points/.meta/tests.toml
new file mode 100644
index 00000000..ca008520
--- /dev/null
+++ b/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"
diff --git a/exercises/practice/saddle-points/SaddlePoints.php b/exercises/practice/saddle-points/SaddlePoints.php
new file mode 100644
index 00000000..c3aa5ce2
--- /dev/null
+++ b/exercises/practice/saddle-points/SaddlePoints.php
@@ -0,0 +1,33 @@
+<?php
+
+/*
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
+ *
+ * To disable strict typing, comment out the directive below.
+ */
+
+declare(strict_types=1);
+
+class SaddlePoints
+{
+    public function saddlePoints(array $matrix): array
+    {
+        throw new \BadMethodCallException("Implement the saddlePoints method");
+    }
+}
diff --git a/exercises/practice/saddle-points/SaddlePointsTest.php b/exercises/practice/saddle-points/SaddlePointsTest.php
new file mode 100644
index 00000000..4df49d68
--- /dev/null
+++ b/exercises/practice/saddle-points/SaddlePointsTest.php
@@ -0,0 +1,215 @@
+<?php
+
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\Attributes\TestDox;
+
+class SaddlePointsTest extends TestCase
+{
+    public static function setUpBeforeClass(): void
+    {
+        require_once 'SaddlePoints.php';
+    }
+
+    /**
+     * uuid: 3e374e63-a2e0-4530-a39a-d53c560382bd
+     */
+    #[TestDox('Can identify single saddle point')]
+    public function testCanIdentifySingleSaddlePoint(): void
+    {
+        $matrix = [
+          [9, 8, 7],
+          [5, 3, 2],
+          [6, 6, 7]
+        ];
+        $expected = [
+            [
+                "row"    => 2,
+                "column" => 1
+            ]
+        ];
+        $song = new SaddlePoints();
+        $this->assertEquals($expected, $song->saddlePoints($matrix));
+    }
+
+    /**
+     * uuid: 6b501e2b-6c1f-491f-b1bb-7f278f760534
+     */
+    #[TestDox('Can identify that empty matrix has no saddle points')]
+    public function testCanIdentifyThatEmptyMatrixHasNoSaddlePoints(): void
+    {
+        $matrix = [[]];
+        $expected = [];
+        $song = new SaddlePoints();
+        $this->assertEquals($expected, $song->saddlePoints($matrix));
+    }
+
+    /**
+     * uuid: 8c27cc64-e573-4fcb-a099-f0ae863fb02f
+     */
+    #[TestDox('Can identify lack of saddle points when there are none')]
+    public function testCanIdentifyLackOfSaddlePointsWhenThereAreNone(): void
+    {
+        $matrix = [
+            [1, 2, 3],
+            [3, 1, 2],
+            [2, 3, 1]
+        ];
+        $expected = [];
+        $song = new SaddlePoints();
+        $this->assertEquals($expected, $song->saddlePoints($matrix));
+    }
+
+    /**
+     * uuid: 6d1399bd-e105-40fd-a2c9-c6609507d7a3
+     */
+    #[TestDox('Can identify multiple saddle points in a column')]
+    public function testCanIdentifyMultipleSaddlePointsInAColumn(): void
+    {
+        $matrix = [
+            [4, 5, 4],
+            [3, 5, 5],
+            [1, 5, 4]
+        ];
+        $expected = [
+            [
+                "row"    => 1,
+                "column" => 2
+            ],
+            [
+                "row"    => 2,
+                "column" => 2
+            ],
+            [
+                "row"    => 3,
+                "column" => 2
+            ]
+        ];
+        $song = new SaddlePoints();
+        $this->assertEquals($expected, $song->saddlePoints($matrix));
+    }
+
+    /**
+     * uuid: 3e81dce9-53b3-44e6-bf26-e328885fd5d1
+     */
+    #[TestDox('Can identify multiple saddle points in a row')]
+    public function testCanIdentifyMultipleSaddlePointsInARow(): void
+    {
+        $matrix = [
+            [6, 7, 8],
+            [5, 5, 5],
+            [7, 5, 6]
+        ];
+        $expected = [
+            [
+                "row"    => 2,
+                "column" => 1
+            ],
+            [
+                "row"    => 2,
+                "column" => 2
+            ],
+            [
+                "row"    => 2,
+                "column" => 3
+            ]
+        ];
+        $song = new SaddlePoints();
+        $this->assertEquals($expected, $song->saddlePoints($matrix));
+    }
+
+    /**
+     * uuid: 88868621-b6f4-4837-bb8b-3fad8b25d46b
+     */
+    #[TestDox('Can identify saddle point in bottom right corner')]
+    public function testCanIdentifySaddlePointInBottomRightCorner(): void
+    {
+        $matrix = [
+            [8, 7, 9],
+            [6, 7, 6],
+            [3, 2, 5]
+        ];
+        $expected = [
+            [
+                "row"    => 3,
+                "column" => 3
+            ]
+        ];
+        $song = new SaddlePoints();
+        $this->assertEquals($expected, $song->saddlePoints($matrix));
+    }
+
+    /**
+     * uuid: 5b9499ca-fcea-4195-830a-9c4584a0ee79
+     */
+    #[TestDox('Can identify saddle points in a non square matrix')]
+    public function testCanIdentifySaddlePointsInANonSquareMatrix(): void
+    {
+        $matrix = [
+            [3, 1, 3],
+            [3, 2, 4]
+        ];
+        $expected = [
+            [
+                "row"    => 1,
+                "column" => 1
+            ],
+            [
+                "row"    => 1,
+                "column" => 3
+            ]
+        ];
+        $song = new SaddlePoints();
+        $this->assertEquals($expected, $song->saddlePoints($matrix));
+    }
+
+    /**
+     * uuid: ee99ccd2-a1f1-4283-ad39-f8c70f0cf594
+     */
+    #[TestDox('Can identify that saddle points in a single column matrix are those with the minimum value')]
+    public function testCanIdentifyThatSaddlePointsInASingleColumnMatrixAreThoseWithTheMinimumValue(): void
+    {
+        $matrix = [
+            [2],
+            [1],
+            [4],
+            [1]
+        ];
+        $expected = [
+            [
+                "row"    => 2,
+                "column" => 1
+            ],
+            [
+                "row"    => 4,
+                "column" => 1
+            ]
+        ];
+        $song = new SaddlePoints();
+        $this->assertEquals($expected, $song->saddlePoints($matrix));
+    }
+
+    /**
+     * uuid: 63abf709-a84b-407f-a1b3-456638689713
+     */
+    #[TestDox('Can identify that saddle points in a single row matrix are those with the maximum value')]
+    public function testCanIdentifyThatSaddlePointsInASingleRowMatrixAreThoseWithTheMaximumValue(): void
+    {
+        $matrix = [
+            [2, 5, 3, 5]
+        ];
+        $expected = [
+            [
+                "row"    => 1,
+                "column" => 2
+            ],
+            [
+                "row"    => 1,
+                "column" => 4
+            ]
+        ];
+        $song = new SaddlePoints();
+        $this->assertEquals($expected, $song->saddlePoints($matrix));
+    }
+}