Swift - przyklad kolosa II

/*Napisz program w jezyku Swift:
1. Utworz klase Osoba majaca pola prywatne: imie, nazwisko, waga, wzrost, pesel oraz typ enum obywatelstwo (case: hiszpanskie, polskie, niemieckie);
2. Klasa Osoba ma miec metody:
a. inicjalizujaca dane;
b. obliczajaca wiek na podstawie peselu oraz podanej daty (uzyj DateFormatter);
c. wyswietlajaca dane;
3. Utworz klase Tenisista, dziedziczaca po klasie Osoba, majaca pola: rodzaj_gry (single, double, singleAndDouble - typ enum), liczba_punktow, obecna_pozycja, najwyzsza_pozycja oraz tablice krotek zawierajaca nazwe turnieju typu String i ilosc punktow typu int;
4. Tenisista ma miec funkcje:
a. inicjalizujaca dane;
b. wyswietlajaca dane klasy, nadpisuje Osoba;
c. dodajace do tablicy kolejny rekord;
5. W programie ma nastapic utworzenie tablicy obiektow klasy Tenisista, a nastepnie wyswietlenie osoby ktora ma rodzaj_gry = double i obywatelstwo = hiszpanskie. Jesli nie bedzie takiej osoby, wyswietl komunikat: "Brak".*/

enum Citizenship {
    case Spanish, Polish, German
}

class Person {
    private var name: String
    private var surname: String
    private var weight: Double
    private var height: Double
    private var pesel: String
    private var citizenship: Citizenship

    init(name: String, surname: String, weight: Double, height: Double, pesel: String, citizenship: Citizenship) {
        self.name = name
        self.surname = surname
        self.weight = weight
        self.height = height
        self.pesel = pesel
        self.citizenship = citizenship
    }

    func calculateAge(date: String) -> Int {
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = "yyyy-MM-dd"
        let birthdate = dateFormatter.date(from: date)
        let currentDate = Date()

        let ageComponents = Calendar.current.dateComponents([.year], from: birthdate!, to: currentDate)
        return ageComponents.year!
    }

    func displayData() {
        print("Name: \(name)")
        print("Surname: \(surname)")
        print("Weight: \(weight)")
        print("Height: \(height)")
        print("Pesel: \(pesel)")
        print("Citizenship: \(citizenship)")
    }
}

enum GameType {
    case single, double, singleAndDouble
}

class TennisPlayer: Person {
    private var gameType: GameType
    private var points: Int
    private var currentPosition: Int
    private var highestPosition: Int
    private var tournamentPoints: [(String, Int)]

    init(name: String, surname: String, weight: Double, height: Double, pesel: String, citizenship: Citizenship, gameType: GameType, points: Int, currentPosition: Int, highestPosition: Int, tournamentPoints: [(String, Int)]) {
        self.gameType = gameType
        self.points = points
        self.currentPosition = currentPosition
        self.highestPosition = highestPosition
        self.tournamentPoints = tournamentPoints
        super.init(name: name, surname: surname, weight: weight, height: height, pesel: pesel, citizenship: citizenship)
    }

    override func displayData() {
        super.displayData()
        print("Game type: \(gameType)")
        print("Points: \(points)")
        print("Current position: \(currentPosition)")
        print("Highest position: \(highestPosition)")
        print("Tournament points: \(tournamentPoints)")
    }

    func addTournamentPoints(tournament: String, points: Int) {
        tournamentPoints.append((tournament, points))
    }
}

var tennisPlayers: [TennisPlayer] = []

// Add some sample data
tennisPlayers.append(TennisPlayer(name: "Rafael", surname: "Nadal", weight: 85, height: 185, pesel: "12345678901", citizenship: .Spanish, gameType: .single, points: 10000, currentPosition: 2, highestPosition: 1, tournamentPoints: [("Wimbledon", 2000), ("US Open", 1500)]))
tennisPlayers.append(TennisPlayer(name: "Roger", surname: "Federer", weight: 80, height: 185, pesel: "23456789012", citizenship: .Swiss, gameType: .double, points: 8000, currentPosition: 3, highestPosition: 1, tournamentPoints: [("Australian Open", 1000), ("French Open", 500)]))
tennisPlayers.append(TennisPlayer(name: "Novak", surname: "Djokovic", weight: 75, height: 185, pesel: "34567890123", citizenship: .Serbian, gameType: .singleAndDouble, points: 6000, currentPosition: 1, highestPosition: 1, tournamentPoints: [("Roland Garros", 750), ("Wimbledon", 1250)]))

var found = false
for player in tennisPlayers {
if player.gameType == .double && player.citizenship == .Spanish {
player.displayData()
found = true
break
}
}
if !found {
print("Brak")
}

/*Napisz program w jezyku Swift:
1. Utworz klase Punkt zawierajaca wspolrzedna x i y punktu;
2. Utworz klase Dane2P majaca prywatne pole odcinek AB, zapisany w postaci krotki punktow klasy Punkt;
3. Klasa Dane2P posiada metody:
a. inicjalizuje dane odcinka;
b. oblicza dlugosc odcinka wg wzoru: d=sqrt((xB-xA)^2+(yB-yA)^2), przyjmuje 2 parametry w postaci punktow;
c. oblicza wspolrzedne wektora zbudowanego na podstawie dwoch punktow przyjetych w parametrze: AB = [xB-xA, yB-yA];
d. wyswietla dane odcinka;
4. W programie utworz tablice z minimum 6 odcinkami, przetestuj wszystkie metody klasy Dane2P dla kazdego z nich, oraz wyswietl trzy odcinki, z ktorych nie mozna zbudowac trojkata, lub informacje ze takowych nie ma (utworz to w funkcji).*/


class Punkt {
    var x: Double
    var y: Double

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

class Dane2P {
    private var odcinekAB: (Punkt, Punkt)

    init(punktA: Punkt, punktB: Punkt) {
        self.odcinekAB = (punktA, punktB)
    }

    func inicjalizujDane(punktA: Punkt, punktB: Punkt) {
        self.odcinekAB = (punktA, punktB)
    }

    func obliczDlugosc() -> Double {
        let xA = odcinekAB.0.x
        let yA = odcinekAB.0.y
        let xB = odcinekAB.1.x
        let yB = odcinekAB.1.y
        return sqrt(pow(xB - xA, 2) + pow(yB - yA, 2))
    }

    func obliczWspolrzedneWektora() -> (Double, Double) {
        let xA = odcinekAB.0.x
        let yA = odcinekAB.0.y
        let xB = odcinekAB.1.x
        let yB = odcinekAB.1.y
        return (xB - xA, yB - yA)
    }

    func wyswietlDane() {
        print("Odcinek AB: (\(odcinekAB.0.x), \(odcinekAB.0.y)) - (\(odcinekAB.1.x), \(odcinekAB.1.y))")
    }
}

func testujMetody() {
    let odcinek1 = Dane2P(punktA: Punkt(x: 2, y: 3), punktB: Punkt(x: 5, y: 7))
    let odcinek2 = Dane2P(punktA: Punkt(x: -1, y: 0), punktB: Punkt(x: 4, y: 3))
    let odcinek3 = Dane2P(punktA: Punkt(x: 3, y: -2), punktB: Punkt(x: 8, y: 1))
    let odcinek4 = Dane2P(punktA: Punkt(x: 0, y: 0), punktB: Punkt(x: 3, y: 4))
    let odcinek5 = Dane2P(punktA: Punkt(x: -2, y: -3), punktB: Punkt(x: 0, y: 0))
    let odcinek6 = Dane2P(punktA: Punkt(x: 1, y: 2), punktB: Punkt(x: 2, y: 4))
    let odcinki = [odcinek1, odcinek2, odcinek3, odcinek4, odcinek5, odcinek6]
for odcinek in odcinki {
    odcinek.wyswietlDane()
    print("Dlugosc odcinka: \(odcinek.obliczDlugosc())")
    print("Wspolrzedne wektora: \(odcinek.obliczWspolrzedneWektora())")
}

var brakTrojkata = true
for i in 0..<odcinki.count {
    for j in i+1..<odcinki.count {
        for k in j+1..<odcinki.count {
            let dlugosc1 = odcinki[i].obliczDlugosc()
            let dlugosc2 = odcinki[j].obliczDlugosc()
            let dlugosc3 = odcinki[k].obliczDlugosc()
            if (dlugosc1 + dlugosc2 > dlugosc3 && dlugosc1 + dlugosc3 > dlugosc2 && dlugosc2 + dlugosc3 > dlugosc1) {
                brakTrojkata = false
                print("Odcinek \(i+1), \(j+1), \(k+1) pozwala na utworzenie trojkata")
            }
        }
    }
}
if brakTrojkata {
    print("Nie ma odcinkow pozwalajacych na utworzenie trojkata")
}
}

testujMetody()