Используя датчик случайных чисел, получить координаты вершин треугольника x1, y1, x2, y2, x3, y3, принадлежащие отрезку [-5,5]

#include "stdafx.h"
#include "stdio.h"
#include "conio.h"
#include "math.h"
int a,b,c;
int ha,hb,hc;
int ma,mb,mc;
int la,lb,lc;
int x1,x2,x3;
int z1,z2,z3;
double p, s;
int _tmain(int argc, _TCHAR* argv[])
{
    printf("Введите длину отрезка a\n");
    scanf("%d", &a);
    printf("Вы ввели число %d, спасибо!\n", a);
    printf("Введите длину отрезка b\n");
    scanf("%d", &b);
    printf("Вы ввели число %d, спасибо!\n", b);
    printf("Введите длину отрезка c\n");
    scanf("%d", &c);
    printf("Вы ввели число %d, спасибо!\n", c);
 {
    if (a+b<c) printf("Треугольник получился\n");
    else if (a+b>c) printf("Не треугольник попробуйте заново\n");
        p=a+b+c;
        printf("Периметр равен: %d\n", p);
    return 0;
    
 }
}

////////////////////////////////////////////////////////////////////////////////////////////
/*
Составьте программу для выполнения следующих заданий:
    1. Ввести с клавиатуры длины отрезков a, b и c.
    2. Проверить, могут ли быть эти отрезки сторонами треугольника, 
и вывести соответствующее сообщение.
    3. Используя формулу Герона и теоремы синусов и косинусов, 
вычислить периметр и площадь треугольника, высоты ha, hb и hc, медианы ma, mb и mc 
и биссектрисы la, lb и lc треугольника.
    4. Вывести результаты вычислений с комментариями на экран дисплея.
    5. Используя датчик случайных чисел, получить координаты вершин 
треугольника x1, y1, x2, y2, x3, y3, принадлежащие отрезку [-5,5].
    6. Не используя формулы Герона и теоремы косинусов, вычислить периметр, 
площадь и медианы треугольника.
    7. Вычислить длины наибольшей и наименьшей сторон треугольника.
    8. Вывести с комментариями результаты вычислений (координаты вершин, периметр, 
площадь и медианы, длины наименьшей и наибольшей сторон треугольника) на экран дисплея.
    9. Напечатать длины сторон в порядке возрастания.
*/
////////////////////////////////////////////////////////////////////////////////////////////
#include <cmath>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <set>
#include <string>
////////////////////////////////////////////////////////////////////////////////////////////
typedef double                 T_coord;
typedef std::complex<T_coord>  T_point;
typedef std::string            T_str;
////////////////////////////////////////////////////////////////////////////////////////////
T_point  vect(T_point  A, T_point  B)
{
    return  B - A;
}
////////////////////////////////////////////////////////////////////////////////////////////
T_coord  triangle_area
    (
        const T_point& A, 
        const T_point& B,
        const T_point& C
    )
{
    T_point AB = vect(A, B);    
    T_point AC = vect(A, C);    
    return abs(AB.real() * AC.imag() - AC.real() * AB.imag()) / 2;
}
////////////////////////////////////////////////////////////////////////////////////////////
bool  are_triangle_sided
    (
        T_coord  a, 
        T_coord  b, 
        T_coord  c
    )
{
    return a < b + c
           && b < a + c
           && c < a + b;
}
////////////////////////////////////////////////////////////////////////////////////////////
T_coord  get_rand_coord_between(T_coord  min, T_coord  max)
{
    return  min + static_cast<T_coord>(rand()) / RAND_MAX * (max - min);
}
////////////////////////////////////////////////////////////////////////////////////////////
T_point  get_rand_point_between(T_coord  min, T_coord  max)
{
    return  T_point(get_rand_coord_between(min, max), get_rand_coord_between(min, max));
}
////////////////////////////////////////////////////////////////////////////////////////////
void  get_rand_triangle_vertices
    (
        T_point&  A, 
        T_point&  B, 
        T_point&  C
    )
{
    T_coord  min = -5;
    T_coord  max = 5;
 
    A = get_rand_point_between(min, max);
    B = get_rand_point_between(min, max);
 
    do
    {
        C = get_rand_point_between(min, max);
    }while(triangle_area(A, B, C) == 0);    
}
////////////////////////////////////////////////////////////////////////////////////////////
T_coord  get_triangle_bisector_c 
    (
        T_coord  a, 
        T_coord  b, 
        T_coord  c
    )
{
    return  sqrt(a * b * (a + b + c) * (a + b - c)) / (a + b);
}
////////////////////////////////////////////////////////////////////////////////////////////
T_coord  get_triangle_median_c
    (
        T_coord  a, 
        T_coord  b, 
        T_coord  c
    )
{
    return sqrt(2 * (a * a + b * b) - c * c) / 2.0;
}
////////////////////////////////////////////////////////////////////////////////////////////
T_coord  get_triangle_median_for_vertex
    (
        T_point  A, 
        T_point  B, 
        T_point  C
    )
{
    T_point  MA = (vect(A, B) + vect(A, C));
    return  abs(MA) / 2;
}
////////////////////////////////////////////////////////////////////////////////////////////
T_coord  get_triangle_perimeter
    (
        T_coord  a, 
        T_coord  b, 
        T_coord  c
    )
{
    return a + b + c;
}
////////////////////////////////////////////////////////////////////////////////////////////
T_coord  get_triangle_perimeter
    (
        T_point  A, 
        T_point  B, 
        T_point  C
    )
{   
    T_coord a = abs(vect(B, C));
    T_coord b = abs(vect(A, C));
    T_coord c = abs(vect(A, B));
    return a + b + c;
}
////////////////////////////////////////////////////////////////////////////////////////////
T_coord  get_triangle_Heron_area
    (
        T_coord  a, 
        T_coord  b, 
        T_coord  c
    )
{
    T_coord p = get_triangle_perimeter(a, b, c) / 2.0;
    return  sqrt(p * (p - a) * (p - b) * (p - c)); 
}
////////////////////////////////////////////////////////////////////////////////////////////
void print_triangle_data()
{
    std::cout << "Введите стороны треугольника:"
              << std::endl;
    T_coord a = 0;
    do
    {
        std::cout << "a = ";
        std::cin >> a;
    }while(a <= 0);
    
    T_coord b = 0;
    do
    {
        std::cout << "b = ";
        std::cin >> b;
    }while(b <= 0);
 
    T_coord c = 0;
    do
    {
        std::cout << "c = ";
        std::cin >> c;
    }while(c <= 0);
 
    bool is_triangle = are_triangle_sided(a, b, c);
    std::cout << "Эти отрезки "
              << (!is_triangle ? "НЕ " : "")
              << "могут быть сторонами треугольника."
              << std::endl;
 
    if(is_triangle)
    {
        std::cout << "Периметр треугольника равен "
            << get_triangle_perimeter(a, b, c)            
            << "."
            << std::endl;
 
        T_coord  S = get_triangle_Heron_area(a, b, c);
        std::cout << "Площадь треугольника равна  "
            << S
            << "."
            << std::endl;
 
        std::cout << std::endl
                  << "Высоты треугольника равны:"
                  << std::endl;
 
        std::cout << "ha = "
                  << 2 * S / a
                  << std::endl;
 
        std::cout << "hb = "
                  << 2 * S / b
                  << std::endl;
 
        std::cout << "hc = "
                  << 2 * S / c
                  << std::endl;
 
        std::cout << std::endl
                  << "Медианы треугольника равны:"
                  << std::endl;
 
        std::cout << "ma = "
                  << get_triangle_median_c(b, c, a)
                  << std::endl;
 
        std::cout << "mb = "
                  << get_triangle_median_c(a, c, b)
                  << std::endl;
 
        std::cout << "mc = "
                  << get_triangle_median_c(a, b, c)
                  << std::endl;
 
        std::cout << std::endl
                  << "Биссектрисы треугольника равны:"
                  << std::endl;
 
        std::cout << "la = "
                  << get_triangle_bisector_c(b, c, a)
                  << std::endl;
 
        std::cout << "lb = "
                  << get_triangle_bisector_c(a, c, b)
                  << std::endl;
 
        std::cout << "lc = "
                  << get_triangle_bisector_c(a, b, c)
                  << std::endl;     
    }
}
////////////////////////////////////////////////////////////////////////////////////////////
void print_rand_triangle_data()
{
    T_point  A;
    T_point  B;
    T_point  C;
    get_rand_triangle_vertices(A, B, C);
    std::cout << "Треугольник со случайно выбранными вершинами:"
              << std::endl
 
              << "A: "
              << A
              << std::endl
              
              << "B: "
              << B
              << std::endl
              
              << "C: "
              << C
              << std::endl
 
              << "Площадь треугольника равна:  "
              << triangle_area(A, B, C)
              << std::endl
 
              << "Периметр треугольника равен: "
              << get_triangle_perimeter(A, B, C)
              << std::endl
              << std::endl
 
              << "Медианы треугольника равны:"
              << std::endl
 
              << "ma = "
              << get_triangle_median_for_vertex(A, B, C)
              << std::endl
 
              << "mb = "
              << get_triangle_median_for_vertex(B, A, C)
              << std::endl
 
              << "mc = "
              << get_triangle_median_for_vertex(C, A, B)
              << std::endl
              << std::endl;
            
    T_coord a = abs(vect(B, C));
    T_coord b = abs(vect(A, C));
    T_coord c = abs(vect(A, B));
    typedef std::set<T_coord>  T_triangle_sides;
    T_triangle_sides  triangle_sides;
    triangle_sides.insert(a);
    triangle_sides.insert(b);
    triangle_sides.insert(c);
    std::cout << "Длина наибольшей стороны треугольника: "               
              << *triangle_sides.rbegin()
              << std::endl
              << "Длина наименьшей стороны треугольника: "               
              << *triangle_sides.begin()
              << std::endl
              << "Длины сторон треугольника в порядке возрастания: "
              << std::endl;
    for(T_triangle_sides::const_iterator  side_it = triangle_sides.begin();
      side_it != triangle_sides.end(); ++side_it)
    {
        std::cout << *side_it
                  << std::endl;
    }
}
////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    srand(static_cast<unsigned>(time(0)));
    const T_str  line 
        = "===============================================================================\n";
    for(;;)
    {
        std::cout << std::endl
                  << std::endl
                  << std::endl 
                  << std::endl 
                  << std::endl 
                  << line
                  << line;
 
        print_triangle_data();
 
        std::cout << std::endl                  
                  << line;
        print_rand_triangle_data();
    }
}

printf("max = %lf\nmin = %lf", max, min);

#include "StdAfx.h"
#include "stdio.h"
#include "ctype.h"
#include "math.h"
#include "cstdlib"
 
 
 
double min, max;
int main()
{
 while (1)
 {
  printf("Лаболаторная работа номер 1\n");
  begin:printf("Выберите действие:\n   1 - Часть 1;\n   2 - Часть 2;\n   X - Выход\n");
  char key;
  key=getc(stdin);
  fflush(stdin);
  key=toupper(key);
  switch (key)
  {
     case '1':
     {
        float a,b,c;
        printf("Введите длину отрезка a\n");
        scanf("%f", &a);
        printf("Введите длину отрезка b\n");
        scanf("%f", &b);
        printf("Введите длину отрезка c\n");
        scanf("%f", &c);
        if (a+b>=c || a+c>=b || b+c>=a) printf("Треугольник получился\n");
        else if (a+b<=c || a+c<=b || b+c<=a) printf("Не треугольник попробуйдете заново\n");
        float p=a+b+c;
        printf("Периметр: %3.3f\n",p);
        p/=2;
        float s=sqrt(p*(p-a)*(p-b)*(p-c));
        printf("Площадь: %3.3f\n",s);
        float h=2*s/a; 
        float asin=h/b;
        float acos=sqrt(1-asin*asin);
        float a2sin=sqrt(0.5*(1+acos));
        float m=h/a2sin;
        float bs=2*s/a2sin/(a+b);
        printf("Высота, медиана, биссектрисса A: %3.3f, %3.3f, %3.3f\n",h,m,bs);
        h=2*s/b;
        asin=h/c;
        acos=sqrt(1-asin*asin);
        a2sin=sqrt(0.5*(1+acos));
        m=h/a2sin;
        bs=2*s/a2sin/(c+b);
        printf("Высота, медиана, биссектрисса B: %3.3f, %3.3f, %3.3f\n",h,m,bs);
        h=2*s/a;
        asin=h/c;
        acos=sqrt(1-asin*asin);
        a2sin=sqrt(0.5*(1+acos));
        m=h/a2sin;
        bs=2*s/a2sin/(a+c);
        printf("Высота, медиана, биссектрисса C: %3.3f, %3.3f, %3.3f\n\n\n",h,m,bs);
        break; 
     }
     case '2':
         {  
             float x1=10*rand()/RAND_MAX-5;
             float x2=10*rand()/RAND_MAX-5;
             float x3=10*rand()/RAND_MAX-5;
             float y1=10*rand()/RAND_MAX-5;
             float y2=10*rand()/RAND_MAX-5;
             float y3=10*rand()/RAND_MAX-5;
             float a=sqrt(pow(x2-x1,2)+pow(y2-y1,2));
             float b=sqrt(pow(x3-x1,2)+pow(y3-y1,2));
             float c=sqrt(pow(x3-x2,2)+pow(y3-y2,2));
             float p=a+b+c;
             printf("Периметр: %3.3f\n",p);
             p/=2;
             float h=2*(sqrt(p*(p-a)*(p-b)*(p-c)))/2;
             float s=0.5*c*h;
             printf("Площадь: %3.3f\n",s);
             float mc=sqrt((2*(a*a) + 2*(b*b) - c*c) / 4);
             float ma=sqrt((2*(c*c) + 2*(b*b) - c*a) / 4);
             float mb=sqrt((2*(a*a) + 2*(c*c) - b*b) / 4);
             printf("Медиана а: %3.3f\n",ma);
             printf("Медиана b: %3.3f\n",mb);
             printf("Медиана c: %3.3f\n\n\n",mc);
                         if (a >= b && a >= c)
             float max = a;
             else
                {
                     if (b >= a && b >= c)
                     float max = b;
                     else
                     float max = c;
                }
 
                    if (a <= b && a <= c)
                    float min = a;
                {
                    if (b <= a && b <= c)
                    float min = b;
                    else
                    float min = c;
                }
                    
 
              printf("max = %lf\nmin = %lf", max, min);
              break;
         }
     case 'X':goto end;break;
     default:goto begin;break;
   }
  }
  getc(stdin);
  end:return 0;
}

#include "StdAfx.h"
#include "stdio.h"
#include "ctype.h"
#include "math.h"
#include "cstdlib"
 
 
 
int main()
{
    float min, max;
 while (1)
 {
  printf("Лаболаторная работа номер 1\n");
  begin:printf("Выберите действие:\n   1 - Часть 1;\n   2 - Часть 2;\n   X - Выход\n");
  char key;
  key=getc(stdin);
  fflush(stdin);
  key=toupper(key);
  switch (key)
  {
     case '1':
     {
        float a,b,c;
        printf("Введите длину отрезка a\n");
                scanf("%f", &a);
                printf("Введите длину отрезка b\n");
                scanf("%f", &b);
                printf("Введите длину отрезка c\n");
                scanf("%f", &c);
                if (a+b>=c || a+c>=b || b+c>=a) printf("Треугольник получился\n");
        else if (a+b<=c || a+c<=b || b+c<=a) printf("Не треугольник попробуйдете заново\n");
                float p=a+b+c;
        printf("Периметр: %3.3f\n",p);
        p/=2;
            float s=sqrt(p*(p-a)*(p-b)*(p-c));
            printf("Площадь: %3.3f\n",s);
                float h=2*s/a;
                float asin=h/b;
                float acos=sqrt(1-asin*asin);
                float a2sin=sqrt(0.5*(1+acos));
                float m=h/a2sin;
                float bs=2*s/a2sin/(a+b);
                printf("Высота, медиана, биссектрисса A: %3.3f, %3.3f, %3.3f\n",h,m,bs);
                h=2*s/b;
                asin=h/c;
                acos=sqrt(1-asin*asin);
                a2sin=sqrt(0.5*(1+acos));
                m=h/a2sin;
                bs=2*s/a2sin/(c+b);
                printf("Высота, медиана, биссектрисса B: %3.3f, %3.3f, %3.3f\n",h,m,bs);
                h=2*s/a;
                asin=h/c;
                acos=sqrt(1-asin*asin);
                a2sin=sqrt(0.5*(1+acos));
                m=h/a2sin;
            bs=2*s/a2sin/(a+c);
            printf("Высота, медиана, биссектрисса C: %3.3f, %3.3f, %3.3f\n\n\n",h,m,bs);
        break;
     }
     case '2':
                 {
                         float x1=10*rand()/RAND_MAX-5;
                         float x2=10*rand()/RAND_MAX-5;
                         float x3=10*rand()/RAND_MAX-5;
                         float y1=10*rand()/RAND_MAX-5;
                         float y2=10*rand()/RAND_MAX-5;
                         float y3=10*rand()/RAND_MAX-5;
                         float a=sqrt(pow(x2-x1,2)+pow(y2-y1,2));
                         float b=sqrt(pow(x3-x1,2)+pow(y3-y1,2));
                         float c=sqrt(pow(x3-x2,2)+pow(y3-y2,2));
                         float p=a+b+c;
                         printf("Периметр: %3.3f\n",p);
                         p/=2;
                         float h=2*(sqrt(p*(p-a)*(p-b)*(p-c)))/2;
                         float s=0.5*c*h;
                         printf("Площадь: %3.3f\n",s);
                         float mc=sqrt((2*(a*a) + 2*(b*b) - c*c) / 4);
                         float ma=sqrt((2*(c*c) + 2*(b*b) - c*a) / 4);
                         float mb=sqrt((2*(a*a) + 2*(c*c) - b*b) / 4);
                         printf("Медиана а: %3.3f\n",ma);
                         printf("Медиана b: %3.3f\n",mb);
                         printf("Медиана c: %3.3f\n\n\n",mc); 
                         max=(a>b)?a:b;
                         max=(max>c)?max:c;
                         min=(a<b)?a:b;
                         min=(min<c)?min:c; 
                         printf("max = %lf\nmin = %lf", max, min);
                         break;
                 }
     case 'X':goto end;break;
         default:goto begin;break;
   }
  }
  getc(stdin);
  end:return 0;
}