Merge pull request ByteByteGoHq#52 from ongshunping/cpp-solutions-math-and-geometry

Add C++ solutions for Chapter 19 (Math and Geometry)

Author: Destiny-02

cpp/Math and Geometry/josephus.cpp

@@ -0,0 +1,10 @@
+int josephus(int n, int k) {
+    // Base case: If there's only one person, the last person is person 0.
+    if (n == 1) {
+        return 0;
+    }
+    // Calculate the position of the last person remaining in the reduced problem 
+    // with 'n - 1' people. We use modulo 'n' to ensure the answer doesn't exceed
+    // 'n - 1'.
+    return (josephus(n - 1, k) + k) % n;
+}

cpp/Math and Geometry/josephus_optimized.cpp

@@ -0,0 +1,8 @@
+int josephusOptimized(int n, int k) {
+    int res = 0;
+    for (int i = 2; i <= n; i++) {
+        // res[i] = (res[i - 1] + k) % i;
+        res = (res + k) % i;
+    }
+    return res;
+}

cpp/Math and Geometry/maximum_collinear_points.cpp

@@ -0,0 +1,47 @@
+#include <vector>
+#include <map>
+#include <utility>
+#include <algorithm>
+#include <numeric> 
+
+int maximumCollinearPoints(std::vector<std::vector<int>>& points) {
+    int res = 0;
+    // Treat each point as a focal point, and determine the maximum
+    // number of points that are collinear with each focal point. The
+    // largest of these maximums is the answer.
+    for (int i = 0; i < points.size(); i++) {
+        res = std::max(res, maxPointsFromFocalPoint(i, points));
+    }
+    return res;
+}
+
+int maxPointsFromFocalPoint(int focalPointIndex, std::vector<std::vector<int>>& points) {
+    std::map<std::pair<int, int>, int> slopesMap;
+    int maxPoints = 0;
+    // For the current focal point, calculate the slope between it and
+    // every other point. This allows us to group points that share the
+    // same slope.
+    for (int j = 0; j < points.size(); j++) {
+        if (j != focalPointIndex) {
+            std::pair<int, int> currSlope = getSlope(points[focalPointIndex], points[j]);
+            slopesMap[currSlope]++;
+            // Update the maximum count of collinear points for the
+            // current focal point.
+            maxPoints = std::max(maxPoints, slopesMap[currSlope]);
+        }
+    }
+    // Add 1 to the maximum count to include the focal point itself.
+    return maxPoints + 1;
+}
+
+std::pair<int, int> getSlope(std::vector<int>& p1, std::vector<int>& p2) {
+    int rise = p2[1] - p1[1];
+    int run = p2[0] - p1[0];
+    // Handle vertical lines separately to avoid dividing by 0.
+    if (run == 0) {
+        return {1, 0};
+    }
+    // Simplify the slope to its reduced form.
+    int gcdVal = std::gcd(rise, run);
+    return {rise / gcdVal, run / gcdVal};
+}

cpp/Math and Geometry/reverse_32_bit_integer.cpp

@@ -0,0 +1,20 @@
+#include <climits> 
+
+int reverse32BitInteger(int n) {
+    int reversedN = 0;
+    // Keep looping until we've added all digits of 'n' to 'reversedN' 
+    // in reverse order.
+    while (n != 0) {
+        // Extract the last digit of 'n'.
+        int digit = n % 10;
+        // Remove the last digit from 'n'.
+        n /= 10;
+        // Check for integer overflow or underflow.
+        if (reversedN > INT_MAX / 10 || reversedN < INT_MIN / 10) {
+            return 0;
+        }
+        // Add the current digit to 'reversedN'.
+        reversedN = reversedN * 10 + digit;
+    }
+    return reversedN;
+}

cpp/Math and Geometry/spiral_matrix.cpp

@@ -0,0 +1,41 @@
+#include <vector>
+
+std::vector<int> spiralMatrix(std::vector<std::vector<int>>& matrix) {
+    if (matrix.empty()) {
+        return {};
+    }
+    std::vector<int> result;
+    // Initialize the matrix boundaries.
+    int top = 0, bottom = matrix.size() - 1;
+    int left = 0, right = matrix[0].size() - 1;
+    // Traverse the matrix in spiral order.
+    while (top <= bottom && left <= right) {
+        // Move from left to right along the top boundary.
+        for (int i = left; i <= right; i++) {
+            result.push_back(matrix[top][i]);
+        }
+        top++;
+        // Move from top to bottom along the right boundary.
+        for (int i = top; i <= bottom; i++) {
+            result.push_back(matrix[i][right]);
+        }
+        right--;
+        // Check that the bottom boundary hasn't passed the top boundary
+        // before moving from right to left along the bottom boundary.
+        if (top <= bottom) {
+            for (int i = right; i >= left; i--) {
+                result.push_back(matrix[bottom][i]);
+            }
+            bottom--;
+        }
+        // Check that the left boundary hasn't passed the right boundary
+        // before moving from bottom to top along the left boundary.
+        if (left <= right) {
+            for (int i = bottom; i >= top; i--) {
+                result.push_back(matrix[i][left]);
+            }
+            left++;
+        }
+    }
+    return result;
+}

cpp/Math and Geometry/triangle_numbers.cpp

@@ -0,0 +1,13 @@
+int triangleNumbers(int n) {
+    // If n is an odd-numbered row, the first even number always starts at position 
+    // 2.
+    if (n % 2 != 0) {
+        return 2;
+    }
+    // If n is a multiple of 4, the first even number always starts at position 3.
+    else if (n % 4 == 0) {
+        return 3;
+    }
+    // For all other rows, the first even number always starts at position 4.
+    return 4;
+}