Junior Proger

Готовые решения

Программа определения типа четырехугольника по координатам четырех вершин

В мире геометрии четырехугольники представляют собой разнообразные фигуры, включая прямоугольники, квадраты, ромбы и произвольные четырехугольники. Определить вид четырехугольника по его координатам вершин может быть нетривиальной задачей, но в то же время, она предоставляет увлекательную возможность визуально анализировать и классифицировать геометрические фигуры. В данной статье мы рассмотрим программу определения вида четырехугольника по координатам четырех вершин.

Теория

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

  • Ввести координаты четырех вершин четырехугольника.
  • Вычислить длины всех сторон четырехугольника, используя формулу для расстояния между двумя точками в двумерном пространстве.
  • Сравнить длины сторон и углы между ними, чтобы определить вид четырехугольника.

C++

Пример программы на C++, в которой вводятся координаты четырёх точек (a, b, c, d) на плоскости, вершины четырехугольника abcd и определяется тип четырёхугольника.

#include <iostream>
#include <cmath>

struct Point {
    double x, y;
};

// Функция для вычисления расстояния между двумя точками
double distance(Point p1, Point p2) {
    return sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
}

// Функция для определения вида четырехугольника
std::string determineQuadrilateralType(Point A, Point B, Point C, Point D) {
    double AB = distance(A, B);
    double BC = distance(B, C);
    double CD = distance(C, D);
    double DA = distance(D, A);

    double diagonalAC = distance(A, C);
    double diagonalBD = distance(B, D);

    if (AB == BC && BC == CD && CD == DA) {
        return "Квадрат";
    } else if (AB == CD && BC == DA) {
        return "Прямоугольник";
    } else if (AB == BC && CD == DA && diagonalAC == diagonalBD) {
        return "Ромб";
    } else {
        return "Произвольный четырехугольник";
    }
}

int main() {
    Point A, B, C, D;
    
    std::cout << "Введите координаты вершины A (x y): ";
    std::cin >> A.x >> A.y;
    std::cout << "Введите координаты вершины B (x y): ";
    std::cin >> B.x >> B.y;
    std::cout << "Введите координаты вершины C (x y): ";
    std::cin >> C.x >> C.y;
    std::cout << "Введите координаты вершины D (x y): ";
    std::cin >> D.x >> D.y;
    
    std::string quadrilateralType = determineQuadrilateralType(A, B, C, D);
    
    std::cout << "Вид четырехугольника: " << quadrilateralType << std::endl;
    
    return 0;
}
0

Это решение было полезно?

Эта программа позволяет вам ввести координаты четырех вершин и определить вид четырехугольника. Примечание: это простая программа, которая предполагает, что введенные координаты образуют четырехугольник. В реальных приложениях требуется дополнительная проверка на то, что координаты вершин образуют действительный четырехугольник.

C#

using System;

public struct Point
{
    public double X;
    public double Y;

    public Point(double x, double y)
    {
        X = x;
        Y = y;
    }
}

public class QuadrilateralTypeDeterminer
{
    public static double Distance(Point p1, Point p2)
    {
        double dx = p1.X - p2.X;
        double dy = p1.Y - p2.Y;
        return Math.Sqrt(dx * dx + dy * dy);
    }

    public static string DetermineQuadrilateralType(Point A, Point B, Point C, Point D)
    {
        double AB = Distance(A, B);
        double BC = Distance(B, C);
        double CD = Distance(C, D);
        double DA = Distance(D, A);

        double diagonalAC = Distance(A, C);
        double diagonalBD = Distance(B, D);

        if (AB == BC && BC == CD && CD == DA)
        {
            return "Квадрат";
        }
        else if (AB == CD && BC == DA)
        {
            return "Прямоугольник";
        }
        else if (AB == BC && CD == DA && diagonalAC == diagonalBD)
        {
            return "Ромб";
        }
        else
        {
            return "Произвольный четырехугольник";
        }
    }

    public static void Main()
    {
        Point A, B, C, D;

        Console.Write("Введите координаты вершины A (x y): ");
        string[] coordinates = Console.ReadLine().Split(' ');
        A = new Point(double.Parse(coordinates[0]), double.Parse(coordinates[1]);

        Console.Write("Введите координаты вершины B (x y): ");
        coordinates = Console.ReadLine().Split(' ');
        B = new Point(double.Parse(coordinates[0]), double.Parse(coordinates[1]);

        Console.Write("Введите координаты вершины C (x y): ");
        coordinates = Console.ReadLine().Split(' ');
        C = new Point(double.Parse(coordinates[0]), double.Parse(coordinates[1]);

        Console.Write("Введите координаты вершины D (x y): ");
        coordinates = Console.ReadLine().Split(' ');
        D = new Point(double.Parse(coordinates[0]), double.Parse(coordinates[1]);

        string quadrilateralType = DetermineQuadrilateralType(A, B, C, D);

        Console.WriteLine("Вид четырехугольника: " + quadrilateralType);
    }
}
0

Это решение было полезно?

Python

import math

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

def distance(p1, p2):
    return math.sqrt((p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2)

def determine_quadrilateral_type(A, B, C, D):
    AB = distance(A, B)
    BC = distance(B, C)
    CD = distance(C, D)
    DA = distance(D, A)

    diagonal_AC = distance(A, C)
    diagonal_BD = distance(B, D)

    if AB == BC == CD == DA:
        return "Квадрат"
    elif AB == CD and BC == DA:
        return "Прямоугольник"
    elif AB == BC == CD == DA and diagonal_AC == diagonal_BD:
        return "Ромб"
    else:
        return "Произвольный четырехугольник"

# Введите координаты вершин
A = Point(float(input("Введите координаты вершины A (x y): ").split()))
B = Point(float(input("Введите координаты вершины B (x y): ").split()))
C = Point(float(input("Введите координаты вершины C (x y): ").split()))
D = Point(float(input("Введите координаты вершины D (x y): ").split()))

quadrilateral_type = determine_quadrilateral_type(A, B, C, D)

print(f"Вид четырехугольника: {quadrilateral_type}")
1

Это решение было полезно?

Программа предполагает, что введенные координаты образуют четырехугольник, и не производит проверку на действительность фигуры.

Java

import java.util.Scanner;

class Point {
    double x, y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
}

public class QuadrilateralTypeDeterminer {
    public static double distance(Point p1, Point p2) {
        double dx = p1.x - p2.x;
        double dy = p1.y - p2.y;
        return Math.sqrt(dx * dx + dy * dy);
    }

    public static String determineQuadrilateralType(Point A, Point B, Point C, Point D) {
        double AB = distance(A, B);
        double BC = distance(B, C);
        double CD = distance(C, D);
        double DA = distance(D, A);

        double diagonalAC = distance(A, C);
        double diagonalBD = distance(B, D);

        if (AB == BC && BC == CD && CD == DA) {
            return "Квадрат";
        } else if (AB == CD && BC == DA) {
            return "Прямоугольник";
        } else if (AB == BC && CD == DA && diagonalAC == diagonalBD) {
            return "Ромб";
        } else {
            return "Произвольный четырехугольник";
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Введите координаты вершины A (x y): ");
        double ax = scanner.nextDouble();
        double ay = scanner.nextDouble();
        Point A = new Point(ax, ay);

        System.out.print("Введите координаты вершины B (x y): ");
        double bx = scanner.nextDouble();
        double by = scanner.nextDouble();
        Point B = new Point(bx, by);

        System.out.print("Введите координаты вершины C (x y): ");
        double cx = scanner.nextDouble();
        double cy = scanner.nextDouble();
        Point C = new Point(cx, cy);

        System.out.print("Введите координаты вершины D (x y): ");
        double dx = scanner.nextDouble();
        double dy = scanner.nextDouble();
        Point D = new Point(dx, dy);

        String quadrilateralType = determineQuadrilateralType(A, B, C, D);

        System.out.println("Вид четырехугольника: " + quadrilateralType);
    }
}
0

Это решение было полезно?

Pascal

program QuadrilateralTypeDeterminer;

uses SysUtils, Math;

type
  Point = record
    x, y: Double;
  end;

function Distance(p1, p2: Point): Double;
begin
  Result := Sqrt(Sqr(p1.x - p2.x) + Sqr(p1.y - p2.y));
end;

function DetermineQuadrilateralType(A, B, C, D: Point): String;
var
  AB, BC, CD, DA, diagonalAC, diagonalBD: Double;
begin
  AB := Distance(A, B);
  BC := Distance(B, C);
  CD := Distance(C, D);
  DA := Distance(D, A);
  diagonalAC := Distance(A, C);
  diagonalBD := Distance(B, D);

  if (AB = BC) and (BC = CD) and (CD = DA) then
    Result := 'Квадрат'
  else if (AB = CD) and (BC = DA) then
    Result := 'Прямоугольник'
  else if (AB = BC) and (CD = DA) and (diagonalAC = diagonalBD) then
    Result := 'Ромб'
  else
    Result := 'Произвольный четырехугольник';
end;

var
  A, B, C, D: Point;
  quadrilateralType: String;

begin
  Write('Введите координаты вершины A (x y): ');
  ReadLn(A.x, A.y);

  Write('Введите координаты вершины B (x y): ');
  ReadLn(B.x, B.y);

  Write('Введите координаты вершины C (x y): ');
  ReadLn(C.x, C.y);

  Write('Введите координаты вершины D (x y): ');
  ReadLn(D.x, D.y);

  quadrilateralType := DetermineQuadrilateralType(A, B, C, D);

  WriteLn('Вид четырехугольника: ', quadrilateralType);
end.
0

Это решение было полезно?

JavaScript

function calculateDistance(p1, p2) {
    return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
}

function determineQuadrilateralType(A, B, C, D) {
    const AB = calculateDistance(A, B);
    const BC = calculateDistance(B, C);
    const CD = calculateDistance(C, D);
    const DA = calculateDistance(D, A);

    const diagonalAC = calculateDistance(A, C);
    const diagonalBD = calculateDistance(B, D);

    if (AB === BC && BC === CD && CD === DA) {
        return "Квадрат";
    } else if (AB === CD && BC === DA) {
        return "Прямоугольник";
    } else if (AB === BC && CD === DA && diagonalAC === diagonalBD) {
        return "Ромб";
    } else {
        return "Произвольный четырехугольник";
    }
}

const readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.question("Введите координаты вершины A (x y): ", function (coordinatesA) {
    const [ax, ay] = coordinatesA.split(' ').map(Number);

    rl.question("Введите координаты вершины B (x y): ", function (coordinatesB) {
        const [bx, by] = coordinatesB.split(' ').map(Number);

        rl.question("Введите координаты вершины C (x y): ", function (coordinatesC) {
            const [cx, cy] = coordinatesC.split(' ').map(Number);

            rl.question("Введите координаты вершины D (x y): ", function (coordinatesD) {
                const [dx, dy] = coordinatesD.split(' ').map(Number);

                const A = { x: ax, y: ay };
                const B = { x: bx, y: by };
                const C = { x: cx, y: cy };
                const D = { x: dx, y: dy };

                const quadrilateralType = determineQuadrilateralType(A, B, C, D);

                console.log("Вид четырехугольника: " + quadrilateralType);

                rl.close();
            });
        });
    });
});
0

Это решение было полезно?

PHP

<?php

function calculateDistance($p1, $p2) {
    return sqrt(pow($p1['x'] - $p2['x'], 2) + pow($p1['y'] - $p2['y'], 2));
}

function determineQuadrilateralType($A, $B, $C, $D) {
    $AB = calculateDistance($A, $B);
    $BC = calculateDistance($B, $C);
    $CD = calculateDistance($C, $D);
    $DA = calculateDistance($D, $A);

    $diagonalAC = calculateDistance($A, $C);
    $diagonalBD = calculateDistance($B, $D);

    if ($AB == $BC && $BC == $CD && $CD == $DA) {
        return "Квадрат";
    } elseif ($AB == $CD && $BC == $DA) {
        return "Прямоугольник";
    } elseif ($AB == $BC && $CD == $DA && $diagonalAC == $diagonalBD) {
        return "Ромб";
    } else {
        return "Произвольный четырехугольник";
    }
}

$A = ['x' => 0, 'y' => 0]; // Замените координаты вершины A
$B = ['x' => 0, 'y' => 4]; // Замените координаты вершины B
$C = ['x' => 3, 'y' => 4]; // Замените координаты вершины C
$D = ['x' => 3, 'y' => 0]; // Замените координаты вершины D

$quadrilateralType = determineQuadrilateralType($A, $B, $C, $D);

echo "Вид четырехугольника: " . $quadrilateralType;

?>
0

Это решение было полезно?

Эта программа позволяет вам определить вид четырехугольника, используя заданные координаты вершин A, B, C и D. Примечание: программа предполагает, что введенные координаты образуют четырехугольник, и не выполняет проверку на действительность фигуры. Вы можете заменить координаты вершин на необходимые для вашего случая.

1 Звезда2 Звезды3 Звезды4 Звезды5 Звезд (Пока оценок нет)
Загрузка...
Давайте поможем друг другу! Если вы нашли ошибку или хотите предложить лучшее решение, пожалуйста, напишите об этом в комментариях.

Может быть полезно

Готовые решения

База данных Access Библиотека

Готовые решения

Программа «Морской бой»

Готовые решения

Программа проверки, состоит ли число из одинаковых цифр

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *