Pythagorean Quadruple In C++

Determine if the four points form a Pythagorean quadruple. This quadruple consists of integers a, b, c, and d, where d 2 = a 2 + b 2 + c 2. Essentially, they are solutions to Diophantine Equations, representing a cuboid with integer side lengths of |a|, |b|, and |c|, and a space diagonal of |d| in geometric terms.

The Pythagorean quadruple (2, 3, 6, 7) is represented by the equation (2^2 + 3^2 + 6^2) = (4 + 9 + 36) = (49) = (7^2). Not all groups of four positive integers qualify as Pythagorean quadruples as they need to adhere to the Pythagorean theorem. These special sets have applications in number theory and are instrumental in creating intriguing mathematical designs.

Algorithm:

• ✅ The vector of numbers should be sorted in non-decreasing order.
• ✅ Determine the total squares of the initial three figures.
• ✅ The fourth number's square should be calculated.
• ✅ Verify the equality of the outcomes acquired from steps two and three.
• ✅ Show the solution.

Pseudo code:

• ✅ Set squareSum to initial.
• ✅ a 2 + b 2 + c 2 = squareSum
• ✅ return (squareSum == d 2 )

Example 1:

Let's consider a scenario to demonstrate the Pythagorean Quadruple in C++.

#include <algorithm>
#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

// Function to check if the given four numbers form a Pythagorean Quadruplet
bool isPythagoreanQuadruplet(const vector<int>& nums) {
    int squareSum = pow(nums[0], 2) + pow(nums[1], 2) + pow(nums[2], 2);
    return (squareSum == pow(nums[3], 2));
}

int main() {
    // Input numbers representing a candidate Pythagorean Quadruplet
    vector<int> numbers = {3, 4, 12, 13}; // Change numbers here

    // Sort the numbers in non-decreasing order
    sort(numbers.begin(), numbers.end());

    // Check if the sorted numbers form a Pythagorean Quadruplet
    if (isPythagoreanQuadruplet(numbers)) {
        cout << "The numbers form a Pythagorean Quadruplet." << endl;
    } else {
        cout << "The numbers do not form a Pythagorean Quadruplet." << endl;
    }

    return 0;
}

Output:

The numbers form a Pythagorean Quadruplet.

Example 2:

Let's consider another instance to demonstrate the Pythagorean Quadruple concept in C++.

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

// Function to check if a given quadruple is Pythagorean
bool isPythagoreanQuadruple(int a, int b, int c, int d) {
    return (pow(a, 2) + pow(b, 2) + pow(c, 2) == pow(d, 2));
}

// Function to find Pythagorean quadruples within a specified range
void findPythagoreanQuadruples(int range) {
    vector<vector<int>> quadruples;

    // Loop through all possible combinations of a, b, c, d within the specified range
    for (int a = 1; a <= range; ++a) {
        for (int b = a; b <= range; ++b) {
            for (int c = b; c <= range; ++c) {
                for (int d = c; d <= range; ++d) {
                    if (isPythagoreanQuadruple(a, b, c, d)) {
                        vector<int> quadruple = {a, b, c, d};
                        quadruples.push_back(quadruple);
                    }
                }
            }
        }
    }

    // Display the Pythagorean quadruples found
    for (const auto &quadruple : quadruples) {
        cout << "(";
        for (int i = 0; i < 4; ++i) {
            cout << quadruple[i];
            if (i < 3) cout << ", ";
        }
        cout << ")" << endl;
    }
}

int main() {
    int range;
    cout << "Enter the range to search for Pythagorean quadruples: ";
    cin >> range;

    findPythagoreanQuadruples(range);

    return 0;
}

Output:

Enter the range to search for Pythagorean quadruples: 15
(1, 2, 2, 3)
(1, 4, 8, 9)
(2, 3, 6, 7)
(2, 4, 4, 6)
(2, 5, 14, 15)
(2, 6, 9, 11)
(2, 10, 11, 15)
(3, 4, 12, 13)
(3, 6, 6, 9)
(4, 4, 7, 9)
(4, 6, 12, 14)
(4, 8, 8, 12)
(5, 10, 10, 15)
(6, 6, 7, 11)

Complexity Analysis:

Time Complexity:

The time complexity remains O(1) as it executes a fixed set of actions. The function ispythagoreanquadruplet calculates the squareSum and verifies if it matches the fourth element squared through three operations that run in constant time.

In the most unfavorable scenario, the time complexity of the sort method amounts to O(nlog(n)). Consequently, the overall time complexity of the code should also be O(nlog(n)), where n represents the number of elements in the vector. Nonetheless, the time complexity of the sort function remains consistent as the vector's size is consistently defined as 4.

Space Complexity:

The space efficiency is O(1) as it only necessitates a minimum of 4 units to hold the input array. With no supplementary space needed for executing the code, the space complexity remains constant.

Conclusion:

In summary, the Pythagorean principle establishes that the square of the fourth integer equals the sum of the squares of the initial three integers. Collections of four whole numbers satisfying this criterion are referred to as Pythagorean quadruplets. If a group of numbers does not constitute a Pythagorean quadruplet, it can be efficiently validated using the C++ code provided. The code systematically evaluates the Pythagorean theorem conditions through the utilization of sorting algorithms and basic arithmetic operations, showcasing a comprehensive understanding of the mathematical concept. The code streamlines integration and emphasizes readability by consolidating the functionality within a single function and adhering to established coding standards.