Работа для курсовой

@Витька · Регистрация: 10.10.2010

Author24 — интернет-сервис помощи студентам

Задание: Даны N точек на плоскости. Для всех треугольников, образуемых любыми тремя точками, определить, является ли треугольник равносторонним.

Как задать эти N точек и как сделать так, штобы выбирались некоторые точки на плоскости. Определить равенство сторон я сам смогу, ну если кто захочет помогите и с этим)))

@Витька · 11.12.2010, 00:01 **[ТС]**

ну што сделайте для норм компилятора плиз!!!!

@lemegeton · 11.12.2010, 03:20

Это и было для "норм компилятора", имеющего некоторый функционал С++х0. Например, такой есть в MSVS C++ 2010 или в GCC 4.5.

Ну вот тебе другая обертка для того же алгоритма.

C++

#include <cmath>
#include <iostream>
#include <ctime>
#include <cstdlib>
 
using namespace std;
 
struct Point
{
        double x;
        double y;
};
 
double _distance(Point &a, Point &b)
{
        return pow(static_cast<double>(pow(a.x - b.x, 2) + pow(a.y - b.y, 2)), static_cast<double>(0.5));
}
 
bool is_isosceles_triangle(Point &a, Point &b, Point &c)
{
        double ab = _distance(a, b);
        double ac = _distance(a, c);
        double bc = _distance(b, c);
        return (abs(ab - ac) < 0.0001) && (abs(ac - bc) < 0.0001) && (abs(ab == bc) < 0.0001);
}
 
class PointSet
{
private:
        Point* _data;
        int _size;
public:
        int size() const { return _size; }
        PointSet() : _data(0), _size(0) {}
        PointSet(int size) : _data(new Point[size]), _size(size) { }
        PointSet(PointSet& other)
                : _data(new Point[other.size()]), _size(other.size())
        {
                for (int i=0; i<_size; i++)
                        _data[i] = other._data[i];
        }
        PointSet& operator=(const PointSet& other)
        {
                if (this != &other)
                {
                        if (_data)
                                delete [] _data;
                        _size = other.size();
                        _data = new Point[_size];
                        for (int i=0; i<_size; i++)
                                _data[i] = other._data[i];
                }
                return *this;
        }
        Point& at(int i) { return _data[i]; }
        Point& operator[](int i) { return _data[i]; }
        ~PointSet() { delete [] _data; }
};
 
int main()
{
        srand(static_cast<unsigned int>(time(0)));
 
        PointSet P(100);
 
        for (int i=0; i<P.size(); i++)
        {
                P[i].x = (rand() % 10000 + 1) / 100.;
                P[i].y = (rand() % 10000 + 1) / 100.;
                cout << "(" << P[i].x << ", " << P[i].y << ") ";
        }
 
        for (int a=0; a<P.size()-2; a++)
                for (int b=a+1; b<P.size()-1; b++)
                        for (int c=b+1; c<P.size(); c++)
                                if (is_isosceles_triangle(P[a], P[b], P[c]))
                                        cout << "(" << P[a].x << ", " << P[a].y << "), "
                                                << "(" << P[b].x << ", " << P[b].y << "), "
                                                << "(" << P[c].x << ", " << P[c].y << "): "
                                                << "is isosceles." << endl;
        cout << endl;
        return 0;
}

Точно собирается на GCC4.4.1.

@Витька · 11.12.2010, 22:39 **[ТС]**

о теперь все работает. то есть он тут задает просто координаты 100 точек на рандом и выводит их на экран да?

Добавлено через 1 минуту
поправка. он задает 100 точек и уже потом из этих 100 ищет совпадения для равества?

Добавлено через 18 часов 55 минут
спасибо большое за помошь!!!

@Витька · 23.12.2010, 01:37 **[ТС]**

можете помочь еще кое в чем?
так как точки задаються на рандом, можно как то иметь два варианта выбора ввода. лиюо вручную либо с помощью рандома. не могли бы вы вписать в прогу команды выбора и штобы было еще написана та часть, когда вводишь вручную.

@lemegeton · 23.12.2010, 01:52

Сообщение от Витька

я первокурсник и с++ изучаю полгода всего.

Вы не научились за пол-года числа с клавиатуры вводить? Почитайте конспекты или учебники. Может быть даже стоит почитать "С++ для чайников".

Не по теме:

"Пол-года" это уже "всего". За пол-года, если не лениться, можно научиться писать модули ядра для linux.

@ForEveR · 23.12.2010, 01:57

Не по теме:

lemegeton, Перебарщиваешь про модули ядра. Хотя смотря к чему стремиться

@Витька · 24.12.2010, 12:23 **[ТС]**

не в этом дело. просто я не все понимаю в этом коде. и как мне состыковать ввод чисел с выходом на рандом и с выходом на ввод чисел для задания точек я незнаю.

Добавлено через 19 часов 31 минуту
ааааа помогите плиз!

@Mr.X · 24.12.2010, 12:52

В вышеприведенных программах один цикл лишний, так как, если мы проверяем две точки A и B на принадлежность равностороннему треугольнику, то, чтобы в этом убедиться, нет необходимости перебирать в качестве третьей вершины C все точки множества, а достаточно вычислить две точки, в которых может находиться вершина C, и проверить, есть ли там точки множества, или нет.
Можно вот так сделать:

C++

/////////////////////////////////////////////////////////////////////////////////////
//Задание: Даны N точек на плоскости. Для всех треугольников, образуемых 
//любыми тремя точками, определить, является ли треугольник равносторонним.
/////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <iomanip>
#include <set>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////
typedef double                 T_coord;
typedef std::complex<T_coord>  T_point;
typedef std::set<T_point>      T_points_set;
typedef T_points_set           T_triangle;
typedef std::set<T_triangle>   T_triangles_set;
/////////////////////////////////////////////////////////////////////////////////////
const T_coord  COORD_EPSILON    = 0.001;
const int      COORD_PRECISION  = -log10(COORD_EPSILON) + 1;
/////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  equal_to_for_real(T a, T b) 
{
    return abs(a - b) < COORD_EPSILON;
}
/////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  greater_for_real(T a, T b) 
{
    return a > b
           && !equal_to_for_real(a, b);
}
/////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  less_for_real(T a, T b) 
{
    return a < b
           && !equal_to_for_real(a, b);
}
/////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  greater_equal_for_real(T a, T b) 
{
    return !less_for_real(a, b);
}
/////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  less_equal_for_real(T a, T b) 
{
    return !greater_for_real(a, b);
}
/////////////////////////////////////////////////////////////////////////////////////
bool operator< (T_point A, T_point B)
{
    return equal_to_for_real(A.real(), B.real()) 
           ? less_for_real(A.imag(), B.imag()) : less_for_real(A.real(), B.real());
}
/////////////////////////////////////////////////////////////////////////////////////
T_point  vect(T_point  A, T_point  B)
{
    return B - A;
}
/////////////////////////////////////////////////////////////////////////////////////
void  get_equilateral_triangle_vertices
    (
        T_point   A, 
        T_point   B, 
        T_point&  C, 
        T_point&  D
    )
{
    //Находим точки C и D такие, что треугольники ABC и ABD являются равносторонними.
    C = A + vect(A, B) * std::polar(1.0,  acos(-1.0) / 3.0);
    D = A + vect(A, B) * std::polar(1.0, -acos(-1.0) / 3.0);
}
/////////////////////////////////////////////////////////////////////////////////////
T_points_set  make_points(size_t  n)
{    
    struct  T_generate_point
    {
        T_generate_point() 
        {}
        //----------------------------------------------------------------------------
        T_point  operator() ()
        {
            T_coord  theta_start      = acos(-1.0) * 2 / 3.0 * (rand() % 3);            
            T_coord  delta_theta_max  = COORD_EPSILON * 1000;
            T_coord  delta_theta_rand 
                = delta_theta_max / RAND_MAX * rand() - delta_theta_max / 2.0;  
            return  std::polar(1.0, theta_start + delta_theta_rand);
        }
    };
 
    T_points_set  points_set_res;
    do
    {
        std::generate_n(std::inserter(points_set_res, points_set_res.begin()), 
                        1, T_generate_point());    
    }while(points_set_res.size() < n);
 
    return  points_set_res;
}
/////////////////////////////////////////////////////////////////////////////////////
T_triangles_set  find_equilateral_triangles(const T_points_set&  points_set)
{
    T_triangles_set  triangles_set_res;
    for(T_points_set::const_iterator  A_it = points_set.begin();
        A_it != points_set.end(); ++A_it)
    {
        T_points_set::const_iterator  B_it_start(A_it);
        ++B_it_start;        
        for(T_points_set::const_iterator  B_it = B_it_start;
            B_it != points_set.end(); ++B_it)
        {
            T_point  C;
            T_point  D;
            get_equilateral_triangle_vertices
                (
                    *A_it,
                    *B_it,
                    C, 
                    D
                );
 
            T_points_set::const_iterator  C_it = points_set.find(C);
            if(C_it != points_set.end())
            {
                T_triangle  triangle_cur;
                triangle_cur.insert(*A_it);
                triangle_cur.insert(*B_it);
                triangle_cur.insert(*C_it);
                if(triangle_cur.size() == 3)
                {
                    triangles_set_res.insert(triangle_cur);
                }                
            }
 
            T_points_set::const_iterator  D_it = points_set.find(D);
            if(D_it != points_set.end())
            {
                T_triangle  triangle_cur;
                triangle_cur.insert(*A_it);
                triangle_cur.insert(*B_it);
                triangle_cur.insert(*D_it);
                if(triangle_cur.size() == 3)
                {
                    triangles_set_res.insert(triangle_cur);
                }                
            }
        }    
    }
    return  triangles_set_res;
}
/////////////////////////////////////////////////////////////////////////////////////
void  print_triangles(const T_triangles_set&  triangles_set)
{
    struct  T_print_triangle
    {
        void  operator() (const T_triangle&  triangle)
        {
            static int  counter = 0;
            std::cout << "треугольник #"
                      << ++counter
                      << ": "
                      << std::endl
                      << '\t';                      
 
            std::copy(triangle.begin(), triangle.end(),                       
                      std::ostream_iterator<T_point>(std::cout, "\n\t"));
            std::cout << std::endl;
        }
    };
    std::for_each(triangles_set.begin(),
                  triangles_set.end(),
                  T_print_triangle());
}
/////////////////////////////////////////////////////////////////////////////////////
void  rand_test()
{
    const int  N_MIN  = 3;
    const int  N_MAX  = 1000;
    int        n      = 0;    
 
    do
    {
        std::cout << "Введите количество генерируемых случайных точек "
                  << N_MIN
                  << " <= N <= "
                  << N_MAX
                  << ": ";
 
        std::cin >> n;    
    }while(   n     < N_MIN
           || N_MAX < n     );
 
    T_points_set     points_set(make_points(n));
    T_triangles_set  equilateral_triangles_set(find_equilateral_triangles(points_set));
    
    std::cout << "Случайные точки:"
              << std::endl
              << std::setprecision(COORD_PRECISION);
    std::copy(points_set.begin(), points_set.end(), 
              std::ostream_iterator<T_point>(std::cout, "\n"));
    std::cout << std::endl;
 
    std::cout << "Из "
              << points_set.size()
              << " сгенерированных случайных точек "
              << equilateral_triangles_set.size()
              << " троек точек "
              << std::endl 
              << "образуют равносторонние треугольники с точностью координат вершин до "
              << COORD_EPSILON 
              << ":"
              << std::endl;
    print_triangles(equilateral_triangles_set); 
}
/////////////////////////////////////////////////////////////////////////////////////
void  points_input()
{
    const int  N_MIN  = 3;
    const int  N_MAX  = 100;
    int        n      = 0;
 
    do
    {
        std::cout << "Введите количество точек, вводимых с клавиатуры "
                  << N_MIN
                  << " <= N <= "
                  << N_MAX
                  << ": ";
 
        std::cin >> n;    
    }while(   n     < N_MIN
           || N_MAX < n    );
 
    std::cout << std::endl
              << "Введите координаты "
              << n 
              << " точек с точностью до "
              << COORD_EPSILON 
              << ":"
              << std::endl;        
    
    T_points_set  points_set;
    do
    {
        std::cout << std::endl
                  << "X"
                  << points_set.size() + 1
                  << " = ";
        
        T_coord  x = 0;
        std::cin >> x;
 
        std::cout << "Y"
                  << points_set.size() + 1
                  << " = ";
        
        T_coord  y = 0;
        std::cin >> y;
        
        points_set.insert(T_point(x, y));
    }while(points_set.size() < static_cast<size_t>(n));
 
    T_triangles_set  equilateral_triangles_set(find_equilateral_triangles(points_set));
 
    std::cout << "Заданные точки:"
              << std::endl
              << std::setprecision(COORD_PRECISION);
    std::copy(points_set.begin(), points_set.end(), 
              std::ostream_iterator<T_point>(std::cout, "\n"));
    std::cout << std::endl;
 
    std::cout << "Из "
              << points_set.size()
              << " заданных точек "
              << equilateral_triangles_set.size()
              << " троек точек "
              << std::endl 
              << "образуют равносторонние треугольники с точностью координат вершин до "
              << COORD_EPSILON 
              << ":"
              << std::endl;
    print_triangles(equilateral_triangles_set); 
}
/////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    srand(static_cast<unsigned>(time(0)));
 
    enum  T_action_variant_num
    {
        RANDOM_POINTS_GENERATING,
        INPUT_OF_POINTS_FROM_THE_KEYBOARD,
        EXIT
    };    
 
    std::cout << "Выберите действие:"
              << std::endl
              << '\t'
              << RANDOM_POINTS_GENERATING
              << " - генерирование случайных точек;"
              << std::endl
              << '\t'
              << INPUT_OF_POINTS_FROM_THE_KEYBOARD
              << " - ввод точек с клавиатуры;"
              << std::endl
              << '\t'
              << EXIT
              << " - выход;"
              << std::endl
              << std::endl
              << "-> ";
 
    int  action_variant_num = 0;
    std::cin >> action_variant_num;
    switch(action_variant_num)
    {
    case RANDOM_POINTS_GENERATING:
        rand_test();
        break;
 
    case INPUT_OF_POINTS_FROM_THE_KEYBOARD:
        points_input();
        break;
 
    default:
    case EXIT:
        ;
    }
}

@Витька · 24.12.2010, 13:30 **[ТС]**

[Warning] converting to `int' from `double'
вот такую ошибку выдает

Добавлено через 2 минуты
Mr.X
а можешь проверить работоспособность на dev-c++ 4.9.9.2?

@Mr.X · 24.12.2010, 13:56

Сообщение от Витька

[Warning] converting to `int' from `double'
вот такую ошибку выдает

Добавлено через 2 минуты
Mr.X
а можешь проверить работоспособность на dev-c++ 4.9.9.2?

Это не ошибка, а предупреждение. У меня только студия. Вот так без предупреждений компилируется:

C++

/////////////////////////////////////////////////////////////////////////////////////
//Задание: Даны N точек на плоскости. Для всех треугольников, образуемых 
//любыми тремя точками, определить, является ли треугольник равносторонним.
/////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <iomanip>
#include <set>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////
typedef double                 T_coord;
typedef std::complex<T_coord>  T_point;
typedef std::set<T_point>      T_points_set;
typedef T_points_set           T_triangle;
typedef std::set<T_triangle>   T_triangles_set;
/////////////////////////////////////////////////////////////////////////////////////
const T_coord  COORD_EPSILON    = 0.001;
const int      COORD_PRECISION  = static_cast<int>(-log10(COORD_EPSILON)) + 1;
/////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  equal_to_for_real(T a, T b) 
{
    return abs(a - b) < COORD_EPSILON;
}
/////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  greater_for_real(T a, T b) 
{
    return a > b
           && !equal_to_for_real(a, b);
}
/////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  less_for_real(T a, T b) 
{
    return a < b
           && !equal_to_for_real(a, b);
}
/////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  greater_equal_for_real(T a, T b) 
{
    return !less_for_real(a, b);
}
/////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  less_equal_for_real(T a, T b) 
{
    return !greater_for_real(a, b);
}
/////////////////////////////////////////////////////////////////////////////////////
bool operator< (T_point A, T_point B)
{
    return equal_to_for_real(A.real(), B.real()) 
           ? less_for_real(A.imag(), B.imag()) : less_for_real(A.real(), B.real());
}
/////////////////////////////////////////////////////////////////////////////////////
T_point  vect(T_point  A, T_point  B)
{
    return B - A;
}
/////////////////////////////////////////////////////////////////////////////////////
void  get_equilateral_triangle_vertices
    (
        T_point   A, 
        T_point   B, 
        T_point&  C, 
        T_point&  D
    )
{
    //Находим точки C и D такие, что треугольники ABC и ABD являются равносторонними.
    C = A + vect(A, B) * std::polar(1.0,  acos(-1.0) / 3.0);
    D = A + vect(A, B) * std::polar(1.0, -acos(-1.0) / 3.0);
}
/////////////////////////////////////////////////////////////////////////////////////
T_points_set  make_points(size_t  n)
{    
    struct  T_generate_point
    {
        T_generate_point() 
        {}
        //----------------------------------------------------------------------------
        T_point  operator() ()
        {
            T_coord  theta_start      = acos(-1.0) * 2 / 3.0 * (rand() % 3);            
            T_coord  delta_theta_max  = COORD_EPSILON * 1000;
            T_coord  delta_theta_rand 
                = delta_theta_max / RAND_MAX * rand() - delta_theta_max / 2.0;  
            return  std::polar(1.0, theta_start + delta_theta_rand);
        }
    };
 
    T_points_set  points_set_res;
    do
    {
        std::generate_n(std::inserter(points_set_res, points_set_res.begin()), 
                        1, T_generate_point());    
    }while(points_set_res.size() < n);
 
    return  points_set_res;
}
/////////////////////////////////////////////////////////////////////////////////////
T_triangles_set  find_equilateral_triangles(const T_points_set&  points_set)
{
    T_triangles_set  triangles_set_res;
    for(T_points_set::const_iterator  A_it = points_set.begin();
        A_it != points_set.end(); ++A_it)
    {
        T_points_set::const_iterator  B_it_start(A_it);
        ++B_it_start;        
        for(T_points_set::const_iterator  B_it = B_it_start;
            B_it != points_set.end(); ++B_it)
        {
            T_point  C;
            T_point  D;
            get_equilateral_triangle_vertices
                (
                    *A_it,
                    *B_it,
                    C, 
                    D
                );
 
            T_points_set::const_iterator  C_it = points_set.find(C);
            if(C_it != points_set.end())
            {
                T_triangle  triangle_cur;
                triangle_cur.insert(*A_it);
                triangle_cur.insert(*B_it);
                triangle_cur.insert(*C_it);
                if(triangle_cur.size() == 3)
                {
                    triangles_set_res.insert(triangle_cur);
                }                
            }
 
            T_points_set::const_iterator  D_it = points_set.find(D);
            if(D_it != points_set.end())
            {
                T_triangle  triangle_cur;
                triangle_cur.insert(*A_it);
                triangle_cur.insert(*B_it);
                triangle_cur.insert(*D_it);
                if(triangle_cur.size() == 3)
                {
                    triangles_set_res.insert(triangle_cur);
                }                
            }
        }    
    }
    return  triangles_set_res;
}
/////////////////////////////////////////////////////////////////////////////////////
void  print_triangles(const T_triangles_set&  triangles_set)
{
    struct  T_print_triangle
    {
        void  operator() (const T_triangle&  triangle)
        {
            static int  counter = 0;
            std::cout << "треугольник #"
                      << ++counter
                      << ": "
                      << std::endl
                      << '\t';                      
 
            std::copy(triangle.begin(), triangle.end(),                       
                      std::ostream_iterator<T_point>(std::cout, "\n\t"));
            std::cout << std::endl;
        }
    };
    std::for_each(triangles_set.begin(),
                  triangles_set.end(),
                  T_print_triangle());
}
/////////////////////////////////////////////////////////////////////////////////////
void  rand_test()
{
    const int  N_MIN  = 3;
    const int  N_MAX  = 1000;
    int        n      = 0;    
 
    do
    {
        std::cout << "Введите количество генерируемых случайных точек "
                  << N_MIN
                  << " <= N <= "
                  << N_MAX
                  << ": ";
 
        std::cin >> n;    
    }while(   n     < N_MIN
           || N_MAX < n     );
 
    T_points_set     points_set(make_points(n));
    T_triangles_set  equilateral_triangles_set(find_equilateral_triangles(points_set));
    
    std::cout << "Случайные точки:"
              << std::endl
              << std::setprecision(COORD_PRECISION);
    std::copy(points_set.begin(), points_set.end(), 
              std::ostream_iterator<T_point>(std::cout, "\n"));
    std::cout << std::endl;
 
    std::cout << "Из "
              << points_set.size()
              << " сгенерированных случайных точек "
              << equilateral_triangles_set.size()
              << " троек точек "
              << std::endl 
              << "образуют равносторонние треугольники с точностью координат вершин до "
              << COORD_EPSILON 
              << ":"
              << std::endl;
    print_triangles(equilateral_triangles_set); 
}
/////////////////////////////////////////////////////////////////////////////////////
void  points_input()
{
    const int  N_MIN  = 3;
    const int  N_MAX  = 100;
    int        n      = 0;
 
    do
    {
        std::cout << "Введите количество точек, вводимых с клавиатуры "
                  << N_MIN
                  << " <= N <= "
                  << N_MAX
                  << ": ";
 
        std::cin >> n;    
    }while(   n     < N_MIN
           || N_MAX < n    );
 
    std::cout << std::endl
              << "Введите координаты "
              << n 
              << " точек с точностью до "
              << COORD_EPSILON 
              << ":"
              << std::endl;        
    
    T_points_set  points_set;
    do
    {
        std::cout << std::endl
                  << "X"
                  << points_set.size() + 1
                  << " = ";
        
        T_coord  x = 0;
        std::cin >> x;
 
        std::cout << "Y"
                  << points_set.size() + 1
                  << " = ";
        
        T_coord  y = 0;
        std::cin >> y;
        
        points_set.insert(T_point(x, y));
    }while(points_set.size() < static_cast<size_t>(n));
 
    T_triangles_set  equilateral_triangles_set(find_equilateral_triangles(points_set));
 
    std::cout << "Заданные точки:"
              << std::endl
              << std::setprecision(COORD_PRECISION);
    std::copy(points_set.begin(), points_set.end(), 
              std::ostream_iterator<T_point>(std::cout, "\n"));
    std::cout << std::endl;
 
    std::cout << "Из "
              << points_set.size()
              << " заданных точек "
              << equilateral_triangles_set.size()
              << " троек точек "
              << std::endl 
              << "образуют равносторонние треугольники с точностью координат вершин до "
              << COORD_EPSILON 
              << ":"
              << std::endl;
    print_triangles(equilateral_triangles_set); 
}
/////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    srand(static_cast<unsigned>(time(0)));
 
    enum  T_action_variant_num
    {
        RANDOM_POINTS_GENERATING,
        INPUT_OF_POINTS_FROM_THE_KEYBOARD,
        EXIT
    };    
 
    std::cout << "Выберите действие:"
              << std::endl
              << '\t'
              << RANDOM_POINTS_GENERATING
              << " - генерирование случайных точек;"
              << std::endl
              << '\t'
              << INPUT_OF_POINTS_FROM_THE_KEYBOARD
              << " - ввод точек с клавиатуры;"
              << std::endl
              << '\t'
              << EXIT
              << " - выход;"
              << std::endl
              << std::endl
              << "-> ";
 
    int  action_variant_num = 0;
    std::cin >> action_variant_num;
    switch(action_variant_num)
    {
    case RANDOM_POINTS_GENERATING:
        rand_test();
        break;
 
    case INPUT_OF_POINTS_FROM_THE_KEYBOARD:
        points_input();
        break;
 
    default:
    case EXIT:
        ;
    }
}

@lemegeton · 24.12.2010, 14:14

Сообщение от Mr.X

и проверить, есть ли там точки множества, или нет.

А проверка, случайно, не перебором всех точек делается?
Чтобы пройтись по всем парам точек нужны циклы двойной вложенности.
Плюс цикл на поиск точки в наборе. Причем этот цикл пройдет по всем точкам набора.

Не по теме:

336 строчек STL кода. Респект.

В моем коде была пара неточностей. Так выглядит проще.
Не нужен был конструктор по-умолчанию, конструктор копирования и оператор присваивания.
Параметры-ссылки передаются в функции как константы.

C++

#include <cmath>
#include <ctime>
#include <cstdlib>
#include <iostream>
 
using std::cout;
using std::endl;
 
struct Point {
  double x;
  double y;
};
 
double calc_distance(const Point &a, const Point &b) {
  return pow(static_cast<double>(pow(a.x - b.x, 2) + pow(a.y - b.y, 2)),
             static_cast<double>(0.5));
}
 
bool is_isosceles_triangle(const Point &a, const Point &b, const Point &c) {
  double ab = calc_distance(a, b);
  double ac = calc_distance(a, c);
  double bc = calc_distance(b, c);
  return (abs(ab - ac) < 0.0001) && (abs(ac - bc) < 0.0001) &&
         (abs(ab == bc) < 0.0001);
}
 
class PointSet {
 public:
  explicit PointSet(int size) : data_(new Point[size]), size_(size) { }
  ~PointSet() { delete [] data_; }
  Point& at(int i) { return data_[i]; }
  int size() const { return size_; }
  Point& operator[](int i) { return data_[i]; }
 private:
  Point* data_;
  int size_;
};
 
int main() {
  srand(static_cast<unsigned int>(time(0)));
 
  PointSet P(100);
 
  for (int i = 0; i < P.size(); ++i) {
    P[i].x = (rand() % 10000 + 1) / 100.;
    P[i].y = (rand() % 10000 + 1) / 100.;
    cout << "(" << P[i].x << ", " << P[i].y << ") ";
  }
 
  for (int a = 0; a < P.size() - 2; ++a)
    for (int b = a + 1; b < P.size() - 1; ++b)
      for (int c = b + 1; c < P.size(); ++c)
        if (is_isosceles_triangle(P[a], P[b], P[c]))
          cout << "(" << P[a].x << ", " << P[a].y << "), "
               << "(" << P[b].x << ", " << P[b].y << "), "
               << "(" << P[c].x << ", " << P[c].y << "): "
               << "is isosceles." << endl;
  cout << endl;
  return 0;
}

@Mr.X · 24.12.2010, 14:27

Сообщение от lemegeton

А проверка, случайно, не перебором всех точек делается?
Чтобы пройтись по всем парам точек нужны циклы двойной вложенности.
Плюс цикл на поиск точки в наборе. Причем этот цикл пройдет по всем точкам набора.

У меня поиск ведется методом find контейнера std::set, который работает с логарифмической скоростью.

@Milka. · 24.12.2010, 18:44

Решить систему уравнений методом Гаусса ,вычислить Н=Е-Х*Хт

8,2х1-3,2х2+14,2х3+14,8х4=-8,4
5,6х1-12х2 +15х3 - 6,4х4=4,5
5,7х1+3,6х2-12,4х3-2,3х4=3,3
6,8х1+13,2х2-6,3х3-8,78х4=14,3

@CyberHunter · 24.12.2010, 20:35

Сообщение от slice

установи среду разработки поновее. visual studio 2010 к примеру.

Есть альтернативный метод решения задачи, не переустанавливая ничего. Написать всё на чистом си, без лямбд.

@Витька · 24.12.2010, 20:36 **[ТС]**

Сообщение от CyberHunter

Есть альтернативный метод решения задачи, не переустанавливая ничего. Написать всё на чистом си, без лямбд.

а как это сделать?

@Витька 0 / 0 / 0 Регистрация: 10.10.2010 Сообщений: 82
	11.12.2010, 00:01 [ТС]	21
	ну што сделайте для норм компилятора плиз!!!! 0

@lemegeton 4769 / 2579 / 892 Регистрация: 29.11.2010 Сообщений: 5,581
	23.12.2010, 01:52	25
	Сообщение от Витька я первокурсник и с++ изучаю полгода всего. Вы не научились за пол-года числа с клавиатуры вводить? Почитайте конспекты или учебники. Может быть даже стоит почитать "С++ для чайников". Не по теме: "Пол-года" это уже "всего". За пол-года, если не лениться, можно научиться писать модули ядра для linux. 0

@Витька 0 / 0 / 0 Регистрация: 10.10.2010 Сообщений: 82
	24.12.2010, 13:30 [ТС]	29
	[Warning] converting to `int' from `double' вот такую ошибку выдает Добавлено через 2 минуты Mr.X а можешь проверить работоспособность на dev-c++ 4.9.9.2? 0

@Mr.X 3224 / 1751 / 436 Регистрация: 03.05.2010 Сообщений: 3,867
	24.12.2010, 14:27	32
	Сообщение от lemegeton А проверка, случайно, не перебором всех точек делается? Чтобы пройтись по всем парам точек нужны циклы двойной вложенности. Плюс цикл на поиск точки в наборе. Причем этот цикл пройдет по всем точкам набора. У меня поиск ведется методом find контейнера std::set, который работает с логарифмической скоростью. 0

@CyberHunter 13 / 13 / 1 Регистрация: 03.08.2010 Сообщений: 61
	24.12.2010, 20:35	34
	Сообщение от slice установи среду разработки поновее. visual studio 2010 к примеру. Есть альтернативный метод решения задачи, не переустанавливая ничего. Написать всё на чистом си, без лямбд. 0

@Витька 0 / 0 / 0 Регистрация: 10.10.2010 Сообщений: 82
		1
	Работа для курсовой 07.12.2010, 23:19. Показов 3448. Ответов 34 Метки нет (Все метки) Задание: Даны N точек на плоскости. Для всех треугольников, образуемых любыми тремя точками, определить, является ли треугольник равносторонним. Как задать эти N точек и как сделать так, штобы выбирались некоторые точки на плоскости. Определить равенство сторон я сам смогу, ну если кто захочет помогите и с этим))) 0

@Витька 0 / 0 / 0 Регистрация: 10.10.2010 Сообщений: 82
	11.12.2010, 22:39 [ТС]	23
	о теперь все работает. то есть он тут задает просто координаты 100 точек на рандом и выводит их на экран да? Добавлено через 1 минуту поправка. он задает 100 точек и уже потом из этих 100 ищет совпадения для равества? Добавлено через 18 часов 55 минут спасибо большое за помошь!!! 0

@Витька 0 / 0 / 0 Регистрация: 10.10.2010 Сообщений: 82
	23.12.2010, 01:37 [ТС]	24
	можете помочь еще кое в чем? так как точки задаються на рандом, можно как то иметь два варианта выбора ввода. лиюо вручную либо с помощью рандома. не могли бы вы вписать в прогу команды выбора и штобы было еще написана та часть, когда вводишь вручную. 0

@ForEveR
	23.12.2010, 01:57 #26
	Не по теме: lemegeton, Перебарщиваешь про модули ядра. Хотя смотря к чему стремиться 0

@Витька 0 / 0 / 0 Регистрация: 10.10.2010 Сообщений: 82
	24.12.2010, 12:23 [ТС]	27
	не в этом дело. просто я не все понимаю в этом коде. и как мне состыковать ввод чисел с выходом на рандом и с выходом на ввод чисел для задания точек я незнаю. Добавлено через 19 часов 31 минуту ааааа помогите плиз! 0

@Milka. 0 / 0 / 0 Регистрация: 24.12.2010 Сообщений: 5
	24.12.2010, 18:44	33
	Решить систему уравнений методом Гаусса ,вычислить Н=Е-Х*Хт 8,2х1-3,2х2+14,2х3+14,8х4=-8,4 5,6х1-12х2 +15х3 - 6,4х4=4,5 5,7х1+3,6х2-12,4х3-2,3х4=3,3 6,8х1+13,2х2-6,3х3-8,78х4=14,3 0

@Витька 0 / 0 / 0 Регистрация: 10.10.2010 Сообщений: 82
	24.12.2010, 20:36 [ТС]	35
	Сообщение от CyberHunter Есть альтернативный метод решения задачи, не переустанавливая ничего. Написать всё на чистом си, без лямбд. а как это сделать? 0