Laborarory: Structures

Write a program to store the parameters of a circle on a 2D plane: the x and y coordinates of the center point and r, the radius. All three parameters are real (floating point) numbers.

• Define a type to store the parameters of a circle.
• Write a function that receives the parameters of two circles as function parameters, and returns whether the two circles overlap or not. (Two circles overlap if the distance between their center points - computed by the Pythagorean theorem - is less than the sum of their radius.)
• Write a function that asks the user to enter the parameters of a circle, creates the circle, and returns it.
• Expand the type definition and the functions to a program that reads the data of two circles, decides if they overlap, and displays a message accordingly.

#include <stdio.h>
#include <math.h>
#include <stdbool.h>

typedef struct Circle {
    double x, y, r;
} Circle;

Circle circle_read() {
    Circle c;
    scanf("%lf %lf %lf", &c.x, &c.y, &c.r);
    return c;
}

int circle_overlap(Circle c1, Circle c2) {
    return sqrt(pow(c1.x-c2.x, 2)+pow(c1.y-c2.y, 2)) < c1.r+c2.r;
}

int main() {
    Circle a, b;
    a = circle_read();
    b = circle_read();
    printf("%s\n", circle_overlap(a, b) ? "They overlap." : "They dont overlap.");
    return 0;
}

Let us define a Point type to store two-dimensional coordinates (x, y)! Write the following functions operating on this data type:

• dist(): calculates the distance between the two points received (using the Pythagorean theorem)
• equal(): checks if to points are equal or not
• read(): reads a point from the keyboard and returns it

In the main, define two points, and test all these functions. When all tests are passed, solve the following task by utilizing the structure and functions defined above:

A farmer wants to surround his land with a wire fence. Write a program to compute how much fence is required! The program asks the farmer to enter the coordinates of the corner points of the fence, calculates the distances, and sums them up. Repeat these steps as long as the new coordinates are not equal to the first one (hence, till we return to the starting point).

It is recommended to store the starting point in a separate variable. After that, two more point variables are needed to calculate the length of a fence segment: one of them stores the current point, and the other the previous one.

Solution

No arrays are needed to solve the task: we always have to remember the previous coordinates only, which will be enough to calculate the length of the new section. Storing the first point in a variable enables us to detect when to stop reading the input and print the result of the program.

#include <stdio.h>
#include <math.h>
#include <stdbool.h>

typedef struct Point {
    double x, y;
} Point;

double dist(Point p1, Point p2) {
    return sqrt(pow(p1.x-p2.x, 2) + pow(p1.y-p2.y, 2));
}

int equal(Point p1, Point p2) {
    return p1.x == p2.x && p1.y == p2.y;
}

Point read(void) {
    Point p;
    scanf("%lf%lf", &p.x, &p.y);
    return p;
}

int main(void) {
    /* Reading the starting point, which is the ending point, too */
    printf("Starting point:\n");
    Point start;
    start = read();

    /* Summation */
    double length = 0;
    printf("Further points:\n");
    Point prev;     /* stores the previous point */
    Point current;  /* stores the new point */
    prev = start;
    do {
        current = read();
        length += dist(prev, current);
        prev = current;        /* for the next iteration */
    } while (!equal(current, start));

    /* Print the sum */
    printf("The length of the fence: %f\n", length);

    return 0;
}