Pythagorean Quadruple In C++

Determine whether the four points make a Pythagorean quadruple . The definition of it is a tuple of integers a, b, c, and d such that d 2 = a 2 + b 2 + c 2 . In essence, they are the answers to the Diophantine Equations. It symbolizes a cuboid with integer side lengths of |a|, |b|, and |c| and a space diagonal of |d| in the geometric interpretation.

The Pythagorean quadruplet (2, 3, 6, 7) can be expressed as (2 2 + 3 2 +6 2 ) = (4 + 9 + 36) = (49) = (7 2 ). All sets of four positive integers cannot be Pythagorean quadruples because they must satisfy the Pythagorean equation. Pythagorean quadruples have been used in number theory and can be used to make interesting patterns in mathematics.

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 us take an example to illustrate 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 us take another example to illustrate the Pythagorean Quadruple 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 is O(1) because it performs a set number of operations. The function ispythagoreanquadruplet computes the squareSum and tests its equality with the fourth element raised to the power of two using three constant-time operations.

In the worst case, the time complexity of the sort function is O(nlog(n)) . Therefore, O(nlog(n)), where n is the vector's element count, should be the code's overall time complexity. However, the sort function's time complexity stays constant because the size of the vector is always set to 4.

Space Complexity:

The space complexity is O(1). This is because 4 is the minimum amount of space needed to store the input vector. Since no additional space is required for the code's implementation, the space complexity can be regarded as constant.

Conclusion:

In conclusion, the Pythagorean theorem states that the square of the fourth number is equal to the sum of the squares of the first three numbers. Sets of four integers that meet this condition are known as Pythagorean quadruplets . If a set of numbers does not form a Pythagorean quadruplet, it can be efficiently verified with the provided C++ code. The code methodically assesses the conditions of the Pythagorean theorem using sorting algorithms and fundamental arithmetic operations, exhibiting a thorough comprehension of the mathematical concept. The code makes integration simple and readability a priority by condensing the functionality into a single function and following set coding conventions.