Find the winner by incrementing co-ordinates till Euclidean distance <= D in C++

Introduction:

In this C++ approach, the objective is to determine a set of winning coordinates by systematically incrementing their values until the Euclidean distance from the origin falls within or equals a specified maximum distance, denoted as 'D'. The algorithm starts with initial coordinates at the origin (0,0) in a 2D plane and employs a systematic incrementation strategy. The Euclidean distance, calculated using the distance formula, serves as the criterion for determining the winning coordinates. This method ensures a structured exploration of the coordinate space, incrementing both x and y values until the desired distance condition is met. The simplicity and clarity of this approach make it an effective way to find a winning point within the specified Euclidean distance systematically and predictably .

Program:

#include <iostream>
#include <cmath>
using namespace std;
// Function to calculate Euclidean distance between two points
double calculateDistance(int x1, int y1, int x2, int y2) {
    return sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2));
}
int main() {
    int x_winner, y_winner;  // Coordinates of the winning point
    double D;  // Maximum allowed distance
    // Input the maximum allowed distance
    cout << "Enter the maximum distance (D): ";
    cin >> D;
    // Loop to iterate through possible coordinates
    for (int x = 0; ; x++) {
        for (int y = 0; ; y++) {
            // Calculate Euclidean distance for the current coordinates
            double distance = calculateDistance(0, 0, x, y);
            // Check if the distance is less than or equal to D
            if (distance <= D) {
                // If yes, set the winner coordinates and break out of the loops
                x_winner = x;
                y_winner = y;
                break;
            }
        }
        // Break out of the outer loop if a winner is found
        if (calculateDistance(0, 0, x_winner, y_winner) <= D) {
            break;
        }
    }
    // Output the winner coordinates
    cout << "The winner coordinates are: (" << x_winner << ", " << y_winner << ")" << endl;
    return 0;
}

Output:

Enter the maximum distance (D): 5
The winner coordinates are: (0, 0)

Explanation:

Introduction:

The code aims to find a winning set of coordinates by gradually incrementing the x and y values until the Euclidean distance from the origin (0,0) to those coordinates is less than or equal to a specified maximum distance, D.

Function to Calculate Euclidean Distance:

The calculateDistance function computes the Euclidean distance between two points using the familiar distance formula: sqrt((x2 - x1)^2 + (y2 - y1)^2).

Main Logic:

User Input:

The program starts by prompting the user to input the maximum allowed distance (D).

Nested Loops:

The code uses nested loops to iterate through possible coordinate values.

Distance Calculation:

For each set of coordinates (x, y), it calculates the Euclidean distance from the origin (0,0) using the calculateDistance function.

Winning Condition Check:

If the calculated distance is less than or equal to the specified maximum distance (D), those coordinates are considered the winner, and the loops break.

Output:

Finally, the program outputs the winning coordinates.

Infinite Loops:

The use of infinite loops is deliberate. The outer loop continues until a winning set of coordinates is found. The inner loop continues indefinitely until a winning condition is met for a particular x value. This ensures a systematic search for the winning coordinates.

Complexity analysis:

Time Complexity:

The time complexity of the code is not straightforward due to the presence of infinite loops. The nested loops increment the x and y coordinates until a winning condition is met, and this process may continue indefinitely until a suitable set of coordinates is found. Therefore, the time complexity is best described as infinite or unbounded.

Space Complexity:

The space complexity of the code is minimal and constant. It doesn't use any data structures or algorithms that would lead to significant memory usage. The primary memory consumption is associated with variables such as x, y, D, distance, and the winner coordinates x_winner and y_winner. These variables occupy a constant amount of memory regardless of the input values. Thus, the space complexity is considered constant or O(1).

Approach 1: Using Linear Search with Step Increment

The approach employs a systematic linear search strategy to find coordinates within a maximum Euclidean distance (D).

It starts from the origin (0, 0) and iteratively increments both x and y coordinates by a fixed step size.

Program:

#include <iostream>
#include <cmath>
using namespace std;
int main() {
    int stepSize = 1;  // Step size for coordinate increment
    double D;  // Maximum allowed distance
    // Input the maximum allowed distance
    cout << "Enter the maximum distance (D): ";
    cin >> D;
    int x = 0, y = 0;
    // Linear search with step increment
    while (true) {
        double distance = sqrt(pow(x, 2) + pow(y, 2));
        // Check if the distance is less than or equal to D
        if (distance <= D) {
            cout << "The winner coordinates are: (" << x << ", " << y << ")" << endl;
            break;
        }
        // Increment coordinates by stepSize
        x += stepSize;
        y += stepSize;
    }
    return 0;
}

Output:

Enter the maximum distance (D): 5
The winner coordinates are: (0, 0)

Explanation:

Initialization:

stepSize is set to 1, indicating the amount by which the coordinates will be incremented in each iteration.

D is the maximum allowed distance, which the program will use to find the winning coordinates.

User Input:

The user is prompted to input the maximum allowed distance (D).

Coordinate Initialization:

x and y are initialized to 0, representing the starting point (origin) in a 2D plane.

Linear Search:

The program enters an infinite loop (while (true)) to perform a linear search for the winning coordinates.

For each iteration of the loop:

The Euclidean distance from the origin (0,0) to the current coordinates (x, y) is calculated using the distance formula.

If the calculated distance is less than or equal to the specified maximum distance (D), the current coordinates are considered as the winner.

The winning coordinates are then displayed, and the loop breaks.

Incrementation:

If the distance condition is not met, the coordinates (x and y) are incremented by the stepSize in each iteration.

This incrementation ensures that the program systematically explores different points in the 2D plane.

Output:

The final output displays the winning coordinates, providing the point that satisfies the condition of being within the specified maximum distance from the origin.

Complexity analysis:

Time Complexity:

The time complexity of the code is determined by the number of iterations in the while (true) loop.

Since the loop increments x and y by a fixed stepSize, until it finds the winning coordinates, the time complexity is linear in terms of the number of iterations.

If we denote the number of iterations as N, the time complexity is O(N).

Space Complexity:

The space complexity of the code is constant (O(1)) because it uses a fixed amount of memory regardless of the input.

The variables stepSize, D, x, y, and distance all occupy a constant amount of memory throughout the execution of the program.

The space required for these variables does not grow with the size of the input.

Approach 2: Using Quadratic Search with Diagonal Movement

This approach adopts a systematic quadratic search strategy to find coordinates within a maximum Euclidean distance (D).

It starts from the origin (0, 0) and incrementally moves in a quadratic pattern, covering more ground diagonally.

Program:

#include <iostream>
#include <cmath>
using namespace std;
int main() {
    int D;  // Maximum allowed distance
    // Input the maximum allowed distance
    cout << "Enter the maximum distance (D): ";
    cin >> D;
    int x = 0, y = 0;
    // Quadratic search with diagonal movement
    while (true) {
        double distance = sqrt(pow(x, 2) + pow(y, 2));
        // Check if the distance is less than or equal to D
        if (distance <= D) {
            cout << "The winner coordinates are: (" << x << ", " << y << ")" << endl;
            break;
        }
        // Increment coordinates quadratically
        x += (x >= y) ? x : y;
        y += (x >= y) ? x : y;
    }
    return 0;
}

Output:

Enter the maximum distance (D): 5
The winner coordinates are: (0, 0)

Explanation:

User Input:

The user is prompted to input the maximum allowed distance (D).

Coordinate Initialization:

x and y are initialized to 0, representing the starting point (origin) in a 2D plane.

Quadratic Search with Diagonal Movement:

The program enters an infinite loop (while (true)) to perform a quadratic search with diagonal movement for the winning coordinates.

For each iteration of the loop:

The Euclidean distance from the origin (0,0) to the current coordinates (x, y) is calculated using the distance formula.

If the calculated distance is less than or equal to the specified maximum distance (D), the current coordinates are considered as the winner.

The winning coordinates are then displayed, and the loop breaks.

Incrementation - Quadratic Movement:

If the distance condition is not met, the coordinates (x and y) are incremented in a quadratic manner.

The larger of the two values (x and y) is added to both x and y in each iteration.

This quadratic incrementation pattern allows the program to cover a larger area in the 2D plane more quickly.

Output:

The final output displays the winning coordinates, providing the point that satisfies the condition of being within the specified maximum distance from the origin.

Complexity analysis:

Time Complexity:

The time complexity of the code depends on the number of iterations in the while (true) loop.

The loop performs a quadratic search pattern, where the number of iterations is influenced by the growth of coordinates x and y.

The time complexity can be considered quadratic, denoted as O(N^2), where N is the number of iterations needed to find the winning coordinates.

Space Complexity:

The space complexity is constant, denoted as O(1), because the amount of memory used by the program remains fixed regardless of the input values.

The variables D, x, y, and distance all occupy a constant amount of memory throughout the execution of the program.

The space required for these variables does not grow with the size of the input.

Approach 3: Random Search with Convergence

The approach uses a random search strategy to find coordinates within a maximum Euclidean distance (D).

It starts with random initial coordinates within a specified range and iteratively adjusts the coordinates randomly.

Program:

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <cmath>
using namespace std;
int main() {
    int D;  // Maximum allowed distance
    // Input the maximum allowed distance
    cout << "Enter the maximum distance (D): ";
    cin >> D;
    srand(time(0));  // Seed for random number generation
    int x = rand() % (2 * D) - D;  // Random initial x within [-D, D]
    int y = rand() % (2 * D) - D;  // Random initial y within [-D, D]
    while (true) {
        double distance = sqrt(pow(x, 2) + pow(y, 2));
        // Check if the distance is less than or equal to D
        if (distance <= D) {
            cout << "The winner coordinates are: (" << x << ", " << y << ")" << endl;
            break;
        }
        // Randomly adjust coordinates
        x += rand() % (2 * D) - D;
        y += rand() % (2 * D) - D;
    }
    return 0;
}

Output:

Enter the maximum distance (D): 6
The winner coordinates are: (-3, 5)

Explanation:

User Input:

The user inputs the maximum allowed distance (D).

Random Initialization:

Random initial coordinates (x and y) within the range [-D, D] are chosen using the rand() function.

The srand(time(0)) call seeds the random number generator based on the current time.

Random Search Iteration:

In each iteration, the program calculates the Euclidean distance from the origin to the current coordinates.

If the calculated distance is less than or equal to D, the current coordinates are considered the winner, and the program terminates.

Otherwise, it adjusts the coordinates randomly to explore different areas of the 2D plane.

Random Adjustment:

Random adjustments are made to both x and y in each iteration.

The adjustments are within the range [-D, D], introducing randomness to the search.

Convergence:

The random adjustments create variability in the coordinates.

Over iterations, the randomness tends to converge towards coordinates that satisfy the Euclidean distance condition.

Output:

Once the winning coordinates are found, the program outputs them.

Complexity Analysis:

Time Complexity:

The time complexity of this approach is challenging to determine due to its random nature precisely .

On average, the time complexity is expected to be relatively high because it depends on the number of iterations needed to find coordinates within the specified Euclidean distance.

The average time complexity might be approximated as O(N), where N is the average number of iterations required.

Space Complexity:

The space complexity is constant, denoted as O(1), because the amount of memory used by the program remains fixed regardless of the input values.

The variables D, x, y, distance, and the random number generation variables all occupy a constant amount of memory throughout the execution of the program.

The space required for these variables does not grow with the size of the input.

Next TopicHow to Access a Local Variable from a Different Function in C++

← prev next →