# 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:

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:

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:

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.

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:

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 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.