swift_na5

/**

                            Online Swift Compiler.
                Code, Compile, Run and Debug Swift script online.
Write your code in this editor and press "Run" button to execute it.

*/

import Foundation;

print("Hello World")

class Punkt {
    var x: Int;
    var y: Int;

    init(x: Int, y: Int) {
        self.x = x;
        self.y = y;
    }
}

class Dane2P {
    var AB: [Punkt] = [];
    init(x1: Int, y1: Int, x2: Int, y2: Int) {
        self.AB.append(Punkt(x: x1, y: y1))
        self.AB.append(Punkt(x: x2, y: y2))
    }

    func printDane() {
        for p in AB {
            print(p.x, p.y)
        }
    }

    func dlugoscOdcinka(p1: Punkt, p2: Punkt) -> Double {

        return sqrt(pow(Double(p2.x - p1.x), 2) + pow(Double(p2.y - p1.y), 2) );
    }

    func wspolrzedneWektora(p1: Punkt, p2: Punkt) -> [Int] {

        return [p2.x - p1.x, p2.y - p1.y];
    }

    func czyTrojkat(p3: Punkt) -> Bool {
        let p1: Punkt = self.AB[0];
        let p2: Punkt = self.AB[1];

        let len1: Double = dlugoscOdcinka(p1: p1, p2: p2);
        let len2: Double = dlugoscOdcinka(p1: p2, p2: p3);
        let len3: Double = dlugoscOdcinka(p1: p1, p2: p3);

        print(len1, len2, len3)

        return !((len1 + len2 == len3) || (len1 + len3 == len2) || (len2 + len3 == len1))
    }
}

class Dane3P: Dane2P {
    var C: Punkt;

    init(x1: Int, y1: Int, x2: Int, y2: Int, x3: Int, y3: Int) {
        self.C = Punkt(x: x3, y: y3);
        super.init(x1: x1, y1: y1, x2: x2, y2: y2);
    }

    override func printDane() {
        print("A[\(self.AB[0].x), \(self.AB[0].y)]");
        print("B[\(self.AB[1].x), \(self.AB[1].y)]");
        print("C[\(self.C.x), \(self.C.y)]");
    }

    func obliczCosa(w1: [Int], w2: [Int]) -> Double {
        let licznik = Double(w1[0] * w2[0] + w1[1] * w2[1]);
        let mianownik = sqrt(Double(w1[0] * w1[0] + w1[1] * w1[1])) * sqrt(Double(w2[0] * w2[0] + w2[1] * w2[1]));
        return licznik / mianownik;
    }

    func czyWspolliniowe() -> Bool {
        let p1: Punkt = self.AB[0];
        let p2: Punkt = self.AB[1];
        let p3: Punkt = self.C

        let len1: Double = dlugoscOdcinka(p1: p1, p2: p2);
        let len2: Double = dlugoscOdcinka(p1: p2, p2: p3);
        let len3: Double = dlugoscOdcinka(p1: p1, p2: p3);

        // print(len1, len2, len3);

        return ((len1 + len2 == len3) || (len1 + len3 == len2) || (len2 + len3 == len1))
    }

    func rodzajTrojkata() -> String {
        var katy: [Double] = katyPomiedzy();
        var max: Double = katy[0];

        for kat in katy {
            if (kat > max) {
                max = kat;
            }
        }

        if (max < 90) {
            return "ostrokatny";
        }
        else if (max ==  90) {
            return "prostokatny";
        }
        else {
            return "rozwartokatny";
        }
    }

    func katyPomiedzy() -> [Double] {
        var katy: [Double] = [];

        let p1: Punkt = self.AB[0];
        let p2: Punkt = self.AB[1];
        let p3: Punkt = self.C

        let w1: [Int] = wspolrzedneWektora(p1: p2, p2: p1);
        let w2: [Int] = wspolrzedneWektora(p1: p2, p2: p3);
        let w3: [Int] = wspolrzedneWektora(p1: p1, p2: p3);

        let wektory: [[[Int]]] = [[w1, w2], [w2, w3], [w1, w3]];

        for w in wektory {
            let cosa: Double = obliczCosa(w1: w[0], w2: w[1]);
            // print(cosa)
            katy.append(acos(cosa) * 180.0 / Double.pi);
        }
        katy[2] = 180 - katy[2];
        for kat in katy {
            print("\(kat) stopni");
        }
        return katy;
    }
}

var d3pArr: [Dane3P] = [];

for _ in 0...5 {
    var randArr: [Int] = []
    for _ in 0...6 {
        let rand: Int = Int.random(in: -10...10);
        randArr.append(rand)
    }
    d3pArr.append(Dane3P(x1: randArr[0], y1: randArr[1], x2: randArr[2], y2: randArr[3], x3: randArr[4], y3: randArr[5]));
}

// dla Dane3P

// for d3p in d3pArr {
//     d3p.printDane();
//     print(d3p.czyWspolliniowe());
//     print(d3p.rodzajTrojkata());
// }

for d3p in d3pArr {
    print(" ");
    let rodzaj = d3p.rodzajTrojkata();
    if (rodzaj  == "ostrokatny") {
        print(">>> Znaleziono <<<");
        d3p.printDane();
    }
    print(rodzaj);
    print(" ");
}

// var d3p = Dane3P(x1: 2, y1: 3, x2: 4, y2: 1, x3: 6, y3: 2);
// d3p.printDane();
// print(d3p.czyWspolliniowe());
// print(d3p.rodzajTrojkata());
// d3p.katyPomiedzy();


// dla Dane2P

// var d2p: [Dane2P] = [];
// for _ in 0...5 {
//     var randArr: [Int] = []
//     for _ in 0...3 {
//         let rand: Int = Int.random(in: -10...10);
//         randArr.append(rand)
//     }
//     d2p.append(Dane2P(x1: randArr[0], y1: randArr[1], x2: randArr[2], y2: randArr[3]))
// }

// for odc in d2p {
//     odc.printDane();
//     print(odc.dlugoscOdcinka(p1: odc.AB[0], p2: odc.AB[1]));
//     print(odc.wspolrzedneWektora());
//     print(odc.czyTrojkat(p3: d2p[3].AB[0]))
// }

// for i in 0...4 {
//     d2p[i].printDane()
//     print(d2p[i].dlugoscOdcinka(p1: d2p[i].AB[0], p2: d2p[i].AB[1]));
//     print(d2p[i].wspolrzedneWektora());
//     for j in 0...1 {
//         print(d2p[i].czyTrojkat(p3: d2p[i + 1].AB[j]));
//     }
// }

// d2p.printDane();
// print(d2p.dlugoscOdcinka())
// print(d2p.wspolrzedneWektora())