Sortowanie tablicy

Witam, pragnę napisać program http://pl.spoj.com/problems/PP0506A/
Dodałem quicksort oraz obliczanie tej odległości, ale teraz nie wiem jak to wszystko spiąć, żeby wyniki były posortowane.
Proszę o uwagi i wskazówki. Pomocy!

#include <iostream>
#include <cmath>
using namespace std;
string a;
int b, c;
double d[1415];
void quicksort(int *tablica, int lewy, int prawy)
{
    int v=tablica[(lewy+prawy)/2];
    int i,j,x;
    i=lewy;
    j=prawy;
    do
    {
        while (tablica[i]<v) i++;
        while (tablica[j]>v) j--;
        if(i<=j)
        {
            x=tablica[i];
            tablica[i]=tablica[j];
            tablica[j]=x;
            i++;
            j--;

        }
    }
    while (i<=j);
    if (j>lewy) quicksort(tablica, lewy, j);
    if (i<prawy) quicksort(tablica, i, prawy);
}

int main()
{
    int *tablica;
    int liczbatestow;
    tablica = new int [liczbatestow];
    cin >>liczbatestow;
    for (int j=0; j<liczbatestow; j++)
    {
        cin >>a;
        cin>>b;
        cin>>c;
        d[1415] = sqrt(pow( b, 2 )+ pow( c, 2 ));
        cout <<d[1415];
    }


    delete []tablica;
    return 0;
}
 

1. Nie używaj zmiennych globalnych.

2. Nie pisz rzeczy, które już istnieją (sort).

3. Na co Ci sortowanie liczb całkowitych, jak masz punkty, których odległość od środka nie będzie całkowita.

4. Używaj struktury (albo czegoś o podobnej funkcjonalności) do trzymania punktu, inaczej jak potem skojarzysz nazwę ze współrzędnymi?

5. Tablica double d[1415]; nie ma elementu o indeksie 1415, więc takie coś to błąd

d[1415] = sqrt(pow( b, 2 )+ pow( c, 2 ));
cout <<d[1415];

Znowu przekombinowałeś. Tak jak pisze @twonek, piszesz funkcje które już są.
Kopsne ci kod z mojego spoja, obczaj sobie ;p

#include <iostream>
#include <algorithm>
#include <string>
#include <cmath>
#include <vector>
struct f{
	std::string a;
	int x;
	int y;
};
bool mfc(const f& fa, const f& za)
{
	if(sqrt(pow(fa.x, 2) + pow(fa.y, 2)) < sqrt(pow(za.x, 2) + pow(za.y, 2))) return true; 
	else return false;
}
using namespace std;
int main()
{
	int lT = 0;
	std::cin >> lT;
	int lP = 0;
	std::vector<std::vector<f>> sorted;
	while(lT--)
	{
		std::cin >> lP;
		std::vector<f> pt;
		while(lP--)
		{
			std::string c; int a, b;
			std::cin >> c >> a >> b;
			pt.push_back(f{c,a,b});
			std::sort(pt.begin(), pt.end(), mfc); 	
		}
		sorted.push_back(pt);
	}
	for(auto x : sorted)
	{
		for(auto m : x)
		{
			std::cout << m.a << " " << m.x << " " << m.y << std::endl;
		}
		std::cout << "\n";
	}
	return 0;
}

Mam sortowanie, ale nie za bardzo wiem jak wypisać te liczby b, c, bo gdy próbuję je wypisać po sortowaniu d, to sortowanie nie następuje
No i problem z przypisaniem litery do tych znaków, jakieś pomysły? :)

#include <iostream>
#include <cmath>
#include <algorithm>
#include <functional>
using namespace std;
int main()
{
   int liczbaprob;
   cin >>liczbaprob;
   for(int i=0; i<liczbaprob; i++)
   {
    string a[10];
    int b, c;
    int e[2001], f[2001];
    double d[1415];
    int liczbatestow;
    cin >>liczbatestow;
    for (int j=0; j<liczbatestow; j++)
    {
        cin >>a[j];
        cin>>b;
        cin>>c;
        d[j] = sqrt(pow( b, 2 )+ pow( c, 2 ));
       a[j]=d[j];
       e[j]=b;
        f[j]=c;
           }
            sort( d, d + liczbatestow);
    for( int j = 0; j < liczbatestow; j++ )
         cout<<a[j]<<" "<<d[j]<<endl;
   }
    return 0;
}
 

a[j]=d[j];

nie wiem co chciałeś osiągnąć tą linią (: szczerze nie wiem nawet jakim cudem łyka to kompilator. Przypisujesz double do std::string? lekkie wtf

Garniturek napisał(a):

No i problem z przypisaniem litery do tych znaków, jakieś pomysły?

Tak jak pisali przedmówcy. Musisz mieć strukturę, która będzie trzymała punkt i nazwę razem. Np.

struct NamedPoint
{
    string name;
    int x, y;
};

Teraz, żeby nie przekazywać do sort callbacka do porównania punktów, przeładowany operator < fajnie się sprawdzi

struct NamedPoint
{
    string name;
    int x, y;

    bool operator<( const NamedPoint &rhs ) const
    {
        double lhsDist,
               rhsDist;

        lhsDist = sqrt( pow( x, 2 ) + pow( y, 2 ) );
        rhsDist = sqrt( pow( rhs.x, 2 ) + pow( rhs.y, 2 ) );

        return lhsDist < rhsDist;
    }
};

Można by się pobawić w dodatkową optymalizację, żeby nie liczyć kilka razy dla jednego punktu jego odległości, ale to sam zrób jak chcesz.

Dla czytelności zdefiniowana zostanie też funkcja do obliczania odległości

double dist( const NamedPoint &p )
{
    return sqrt( pow( p.x, 2 ) + pow( p.y, 2 ) );
}

Wreszcie cały kod będzie wyglądał tak

#include <iostream>
#include <cmath>
#include <algorithm>
#include <functional>
#include <string>
#include <array>

using namespace std;

struct NamedPoint;
double dist( const NamedPoint & );

struct NamedPoint
{
    string name;
    int x, y;

    bool operator<( const NamedPoint &rhs ) const
    {
        double lhsDist,
               rhsDist;

        lhsDist = dist( *this );
        rhsDist = dist( rhs );

        return lhsDist < rhsDist;
    }
};

double dist( const NamedPoint &p )
{
    return sqrt( pow( p.x, 2 ) + pow( p.y, 2 ) );
}

int main()
{
    size_t liczbaprob;
    cin >> liczbaprob;
    for( size_t i = 0; i<liczbaprob; i++ )
    {
        const size_t MAX_NUMBER_OF_POINTS = 1000;

        array<NamedPoint, MAX_NUMBER_OF_POINTS> points;
        size_t liczbatestow;

        cin >> liczbatestow;
        for( size_t j = 0; j<liczbatestow; j++ )
        {
            cin >> points[j].name \
                >> points[j].x \
                >> points[j].y;
        }

        sort( points.begin(), points.begin() + liczbatestow );

        for( size_t j = 0; j<liczbatestow; j++ )
            cout << points[j].name << " " << dist( points[j] ) << endl;

        cout << endl;
    }
    return 0;
}

Dziękuje wszystkim za pomoc, jesteście Wielcy :)