1. zadatak:

import math

class Kompleks:
    def __init__(self, a=0.0, b=0.0):
        self.a = float(a)
        self.b = float(b)

    def __repr__(self):
        if self.b >= 0:
            return f"{self.a}+{self.b}i"
        else:
            return f"{self.a}{self.b}i"

    def __add__(self, other):
        return Kompleks(self.a + other.a, self.b + other.b)

    def __sub__(self, other):
        return Kompleks(self.a - other.a, self.b - other.b)

    def __mul__(self, other):
        real = self.a * other.a - self.b * other.b
        imag = self.a * other.b + self.b * other.a
        return Kompleks(real, imag)

    def modul(self):
        return math.sqrt(self.a ** 2 + self.b ** 2)


# primjer za testiranje 
z1 = Kompleks(3, 4)
z2 = Kompleks(1, -2)

print("z1 =", z1)
print("z2 =", z2)
print("z1 + z2 =", z1 + z2)
print("z1 - z2 =", z1 - z2)
print("z1 * z2 =", z1 * z2)
print("|z1| =", z1.modul())


# 2. zadatak:
class Matrica:
    def __init__(self, m, n, vrijednost=0):
        if m <= 0 or n <= 0:
            raise ValueError("Dimenzije moraju biti pozitivne cijele vrijednosti!")
        self.m = m
        self.n = n
        self.podaci = [[vrijednost for _ in range(n)] for _ in range(m)]

    def get(self, i, j):
        if not (0 <= i < self.m and 0 <= j < self.n):
            raise IndexError("Indeksi izvan granica matrice!")
        return self.podaci[i][j]

    def set(self, i, j, v):
        if not (0 <= i < self.m and 0 <= j < self.n):
            raise IndexError("Indeksi izvan granica matrice!")
        self.podaci[i][j] = v

    def transponiraj(self):
        nova = Matrica(self.n, self.m)
        for i in range(self.m):
            for j in range(self.n):
                nova.podaci[j][i] = self.podaci[i][j]
        return nova

    def __repr__(self):
        s = ""
        for red in self.podaci:
            s += " ".join(f"{x:6}" for x in red) + "\n"
        return s

# primjer za testiranje
A = Matrica(2, 3)
A.set(0, 0, 1)
A.set(0, 1, 2)
A.set(1, 2, 5)

print("Matrica A:")
print(A)

print("Transponirana matrica At:")
print(A.transponiraj())


# 3. zadatak:
class Vrijeme:
    def __init__(self, h=0, m=0):
        total = h * 60 + m
        total %= 24 * 60
        self.h = total // 60
        self.m = total % 60

    def __repr__(self):
        return f"{self.h:02d}:{self.m:02d}"

    def __add__(self, minute):
        if not isinstance(minute, int):
            raise TypeError("Vrijeme se može zbrajati samo s brojem minuta (int)!")
        total = (self.h * 60 + self.m + minute) % (24 * 60)
        return Vrijeme(total // 60, total % 60)

    def __sub__(self, minute):
        if not isinstance(minute, int):
            raise TypeError("Vrijeme se može oduzimati samo s brojem minuta (int)!")
        total = (self.h * 60 + self.m - minute) % (24 * 60)
        return Vrijeme(total // 60, total % 60)

    def __iadd__(self, minute):
        if not isinstance(minute, int):
            raise TypeError("Vrijeme se može uvećati samo za broj minuta (int)!")
        total = (self.h * 60 + self.m + minute) % (24 * 60)
        self.h, self.m = total // 60, total % 60
        return self

    def __isub__(self, minute):
        if not isinstance(minute, int):
            raise TypeError("Vrijeme se može smanjiti samo za broj minuta (int)!")
        total = (self.h * 60 + self.m - minute) % (24 * 60)
        self.h, self.m = total // 60, total % 60
        return self

# primjer za testiranje
v = Vrijeme(23, 50)
print("Početno:", v)
print("v + 30 =", v + 30)
print("v - 90 =", v - 90)
v += 80
print("Nakon += 80:", v)
v -= 200
print("Nakon -= 200:", v)
print("Normalizirano:", Vrijeme(25, 70))


# 4. zadatak:
import math

class Tocka:
    def __init__(self, x=0.0, y=0.0):
        self.x = float(x)
        self.y = float(y)

    def udaljenost(self, t):
        return math.sqrt((self.x - t.x)**2 + (self.y - t.y)**2)

    def __repr__(self):
        return f"({self.x}, {self.y})"


class Trokut:
    def __init__(self, A, B, C):
        self.A = A
        self.B = B
        self.C = C

    def _stranice(self):
        a = self.B.udaljenost(self.C)
        b = self.A.udaljenost(self.C)
        c = self.A.udaljenost(self.B)
        return a, b, c

    def opseg(self):
        a, b, c = self._stranice()
        return a + b + c

    def povrsina(self):
        a, b, c = self._stranice()
        s = (a + b + c) / 2
        return math.sqrt(s * (s - a) * (s - b) * (s - c))

    def tip(self):
        a, b, c = self._stranice()
        eps = 1e-9
        if abs(a - b) < eps and abs(b - c) < eps:
            return "jednakostraničan"
        elif abs(a - b) < eps or abs(b - c) < eps or abs(a - c) < eps:
            return "jednakokračan"
        else:
            return "raznostraničan"

    def __repr__(self):
        return f"Trokut: A={self.A}, B={self.B}, C={self.C}"

# podaci za testiranje
A = Tocka(0, 0)
B = Tocka(3, 0)
C = Tocka(0, 4)

t = Trokut(A, B, C)

print(t)
print("Stranice:", t._stranice())
print("Opseg:", t.opseg())
print("Površina:", t.povrsina())
print("Tip trokuta:", t.tip())