Tablica struktur

0

Witam,
potrzebuję napisać program w którym jest:
struktura x i y dwuwymiarowa

użytkownik podaje n,
tworzymy tablice n(typu struktury)
losujemy wartości,
wysyłamy tablice do funkcji
funkcja ma wyznaczyć punkt najdalej od punktu tab[0]

Np. mamy stos

9 9
5 6
1 2

to wyznaczamy odleglosc od 1 2 do punktu najdalej położonego

1

200zł.

0

Nikt nie pomoże?

0

To co podałeś to jednowymiarowa tablica, o zawartości elementu struktury x,y.

0
Sasiad napisał(a):

Witam,
struktura x i y dwuwymiarowa

eee struktura dwuwymiarowa?
a nie tablica?

0

Temat stanął w miejscu (pewnie autor zrezygnował). Podepnę się.
Napisałem to dla wprawki. Czy to jest zgodne z C?

#include <stdio.h>
#include <math.h>
#include <time.h>
#include <stdlib.h>

struct Point {
    int x_;
    int y_;
};

void printPoint(struct Point* point)
{
    printf("x: %i   y: %i", point->x_, point->y_);
}

struct Point randomPoint()
{
    struct Point point;
    point.x_ = (rand() % 21) - 10;
    point.y_ = (rand() % 21) - 10;
    return point;
}

void fillPoints(struct Point points[], size_t size)
{
    for (size_t i = 0; i < size; ++i) {
        points[i] = randomPoint();
    }
}

double distance(const struct Point* mainPoint, const struct Point* actualPoint) {
    return sqrt(
          ((actualPoint->x_ - mainPoint->x_) * (actualPoint->x_ - mainPoint->x_))
        + ((actualPoint->y_ - mainPoint->y_) * (actualPoint->y_ - mainPoint->y_))
    );
}

struct Point findMaxDistancePoint(const struct Point* points, size_t size, double* maxDistance)
{
    struct Point searchPoint;

    for (size_t i = 1; i < size; ++i) {
        double currentDistance = distance(points, points + i);
        if (*maxDistance < currentDistance) {
            *maxDistance = currentDistance;
            searchPoint = *(points + i);
        }
    }
    return searchPoint;
}

int main(void)
{
    srand(time(NULL));
    double maxDistance = 0.0;
    size_t size;
    scanf("%i", &size);

    struct Point* points = (struct Point*)malloc(sizeof(struct Point) * size);
    if (points == NULL) {
        perror("Memory");
        exit(EXIT_FAILURE);
    }

    fillPoints(points, size);
    struct Point maxDistancePoint = findMaxDistancePoint(points, size, &maxDistance);

    printf("maks dystanse jest miedzy punktami:\n");
    printPoint(points);
    printf("\noraz\n");
    printPoint(&maxDistancePoint);
    printf("\ni wynosi %lf\n", maxDistance);

    free(points);

    return 0;
} 

Nie "krzyczcie" zbyt mocno. Zacząłem od C++, ale chcę też chociaż liznąć C.

1

Na pierwszy rzut oka wygląda dobrze.
Może dałbym stały wskaźnik:
void fillPoints(struct Point points[], size_t size)

Może bym usunął power i ręcznie wymnożył.

To może bym tak zapisał:
struct Point* points = (struct Point*)malloc(sizeof(Point) * size );

Czy to działa? Ja daję zawsze %lf.
printf("\ni wynosi %lf\n", maxDistance);

Pozdrawiam

0

wariant 1:

double distance(const struct Point* mainPoint, const struct Point* actualPoint) {
    return sqrt(
          pow(actualPoint->x_ - mainPoint->x_, 2) + pow(actualPoint->y_ - mainPoint->y_, 2)
    );
}
 

wariant 2:

double distance(const struct Point* mainPoint, const struct Point* actualPoint) {
    return sqrt(
          ((actualPoint->x_ - mainPoint->x_) * (actualPoint->x_ - mainPoint->x_))
        + ((actualPoint->y_ - mainPoint->y_) * (actualPoint->y_ - mainPoint->y_))
    );
} 

Wariant 1 jest zwięzły, wariant 2 mniej.
Czemu

Może bym usunął power i ręcznie wymnożył.

?

1

Funkcja power jest strasznie wolne, a gdy programuję w C/C++, to zwykle dlatego żeby program szybko działał :D
Gdy wydajność nie ma znaczenia, to można zostawić power. Można też napisać swoją wersję
double power2( const double x ) {
return x*x;
}
Będzie wydajnie i przejrzyście.
Pozdrawiam

1 użytkowników online, w tym zalogowanych: 0, gości: 1