Tablice dwuwymiarowe, a współrzędne

Witam.
Dostałem zadanie o treści:

Tablica tab_punkty zawiera współrzędne N punktów na płaszczyźnie. Napisz funkcję tworzącą tablicę odległości punktów od początku układu współrzędnych. Wskaźnik do tablicy jest przekazany z funkcji przez return. Napisz program, w którym wczytane są dane, wywołana funkcja, wyświetlone wyniki.

Mam problem jak skutecznie wczytać współrzędne X i Y punktów do tablicy, a potem jeszcze dobrze utworzyć dynamicznie tablicę z wynikami odległości.
Tyle napisałem, ale nie działa to do końca skutecznie:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
float* licze(int N, int l, float tab[][N]);

int main()
{
    int N, i, j, l = 0;
    float* t;
    printf("Podaj liczbe wspolrzednych N: ");
    scanf("%d", &N);

    float tab[2][N];
    for (i = 0; i < 2; i++)
        for (j = 0; j < N; j++)
        {
            printf("Podaj wspolrzedne: ");
            scanf("%f", &tab[i][j]);
            l++;
        }
    for (i = 0; i < 2; i++)
    {
        for (j = 0; j < N; j++) // wykonanie tej pętli powoduje
            printf("%f\t", tab[i][j]); // wyświetlenie i-tego  wiersza tablicy
        printf("\n");
    }
    t = licze(N, l, tab);
    for (i = 0; i < l; i++)
    {
        printf("%f\t", t[i]); // wyświetlenie i-tego  wiersza tablicy
        printf("\n");
    }

    return 0;
}

float* licze(int N, int l, float tab[][N])
{
    int i, j, k = 0;
    float* nt = (float*)malloc(l * sizeof(float));
    for (i = 0; i < 2; i++)
        for (j = 0; j < N; j++)
        {
            nt[k] = sqrt((tab[1][i]) * (tab[0][j]));
            k++;
        }
    return nt;
}

W zadaniu nie ma ani słowa o tablicach dwuwymiarowych. Masz jednowymiarową tablicę współrzędnych.

Przyjmij, że masz

struct Coordinate
{
    float x, y;
};

i tablicę tego.

Więc jak to umiejętnie pobrać, bo chyba zgłupiałem przez prostotę tego.

Nie miałem jeszcze struktur, w tym cały sęk.

Nic nie stoi na przeszkodzie aby się doedukować. To nie jest specjalnie trudne, a znacząco ułatwi Ci zadanie.

No cóż, więc spróbuję się poduczyć na zaś, a jakieś podpowiedzi jak to ugryźć bez?

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

typedef struct {
	void *elements;
	size_t element_size;
	size_t size;
} array_t;

void *get_array_element(array_t array, size_t idx) {
	assert(idx < array.size);
	return array.elements + idx*array.element_size;
}

array_t create_array(size_t size_of_array, size_t size_of_element) {
	assert(size_of_array > 0);
	assert(size_of_element > 0);
	
	array_t result = {
		malloc(size_of_array*size_of_element),
		size_of_element,
		size_of_array
	};
	
	return result;
}

void free_array_mem(array_t array) {
	free(array.elements);
}

typedef struct {
	float x, y;
} point_t;

float calc_point_length(point_t point) {
	return sqrt(point.x*point.x + point.y*point.y);
}

array_t transform_points_to_lengths(array_t points) {
	assert(points.element_size == sizeof(point_t));
	array_t result = create_array(points.size, sizeof(float));
	int i = 0;
	for(; i < points.size; i += 1) {
		float *result_el = get_array_element(result, i);
		point_t *point_el = get_array_element(points, i);
		*result_el = calc_point_length(*point_el);
	}
	return result;
}

array_t read_points(FILE *file) {
	int size = 0;
	fscanf(file, "%d", &size);
	array_t result = create_array(size, sizeof(point_t));
	int i = 0;
	for(; i < size; i += 1) {
		point_t *el = get_array_element(result, i);
		fscanf(file, "%f %f", &el->x, &el->y);
	}
	return result;
}

int main(void) {
	array_t points = read_points(stdin);
	array_t lengths = transform_points_to_lengths(points);
	
	int i = 0;
	for(; i < lengths.size; i += 1) {
		point_t *point = get_array_element(points, i);
		float *length = get_array_element(lengths, i);
		printf("[%f, %f] = %f\n", point->x, point->y, *length);
	}
	
	free_array_mem(points);
	free_array_mem(lengths);
	return 0;
}

http://ideone.com/sfzJ1G

3
1 1
2 2
3 -3.5

|

[1.000000, 1.000000] = 1.414214
[2.000000, 2.000000] = 2.828427
[3.000000, -3.500000] = 4.609772

Tutaj to już prawie żadnej linijki nie rozumiem.

No to prościej:

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

float* calcDistance(int count, float tab[][2], float x0, float y0)
{
	float* distance = (float*)malloc(count*sizeof(float));
	
	int i;
	for(i = 0; i < count; i++)
	{
		distance[i] = sqrt((tab[i][0] - x0)*(tab[i][0] - x0) + (tab[i][1] - y0)*(tab[i][1] - y0));
	}
	
	return distance;
}

int main()
{
    int count, i;
	float *t;
	
	printf("Podaj liczbe wspolrzednych N: ");
	scanf("%d", &count);

	float tab[count][2];
	
	for (i = 0; i < count; i++)
	{
		printf("Punkt: %d \n", i);
		printf("Podaj wspolrzedna x:");
		scanf("%f", &tab[i][0]);
		printf("Podaj wspolrzedna y:");
		scanf("%f", &tab[i][1]);
	}
	
	t = calcDistance(count, tab, 0, 0);
	
	printf("Tablica odleglosci od punktu (0, 0): \n");
	for (i = 0; i < count; i++)
	{
		printf("punkt %d: %f \n", i, t[i]);
	}
    system("PAUSE");
	return 0;
}

Niepotrzebnie tworzysz tablicę punktów tak:

float tab[2][N];

dla punktów na płaszczyźnie bardziej naturalne będzie

float tab[N][2];

wtedy nie będzie problemu z wczytaniem współrzędnych punktu o indeksie i z tablic bo

 
x = tab[i][0];
y = tab[i][1];

po drugie nie będzie problemu z przekazaniem tej tablicy do funkcji, bo teraz kompilator będzie się pluł że nie zna N przy deklaracji funkcji:

 
float* licze(int N, int l, float tab[][N]); 

a jak będzie na odwrót to po prostu napiszesz

 
float* licze(int N, int l, float tab[][2])

no i nieporzebna zmienna l.
No i kq ma racje, jakbyś zastosował strukturę to byś miał łatwiej.

Pomóż innym pomóc sobie - wklej kod, który kompilujesz, jeżeli go zmieniłeś. U mnie, na Win8 używając MinGW/GCC 6.1 od STL (nuwen.net) czyli nowszej wersji GCC niż jest dołączona do C::B, nic się nie wywala:

$ gcc --pedantic -Wall -Wextra -std=c11 -g t.c

$ ./a
Podaj liczbe wspolrzednych N: 2
Punkt: 0
Podaj wspolrzedna x:12
Podaj wspolrzedna y:22
Punkt: 1
Podaj wspolrzedna x:19
Podaj wspolrzedna y:29
Tablica odleglosci od punktu (0, 0):
punkt 0: 25.059929
punkt 1: 34.669872
Press any key to continue . . .

To nie wina kodu (chociaż jest tam niewinny wyciek pamięci), a raczej PEBKAC.

@czaffik nie uważasz, że calcDistance robi trochę za dużo?