GRUPA A
// Zadanie 1 - Obliczanie pierwiastka kwadratowego
#include <iostream>
#include <cmath>

using namespace std;

double pierwiastekKwadratowy(double x, double epsilon = 0.00001) {
    // Zwróć x, jeśli jest blisko 0
    if (x == 0) return 0;

    // Inicjalizacja zmiennej początkowej
    double guess = x / 2.0;

    // Iteracyjne obliczanie pierwiastka kwadratowego
    while (abs(guess * guess - x) > epsilon) {
        guess = (guess + x / guess) / 2.0;
    }

    return guess;
}

int main() {
    double liczba;
    cout << "Podaj liczbe: ";
    cin >> liczba;

    // Sprawdzenie czy liczba jest nieujemna
    if (liczba < 0) {
        cout << "Nie można obliczyć pierwiastka kwadratowego z liczby ujemnej!" << endl;
        return 1;
    }

    // Wywołanie funkcji obliczającej pierwiastek kwadratowy i wyświetlenie wyniku
    cout << "Pierwiastek kwadratowy z " << liczba << " wynosi: " << pierwiastekKwadratowy(liczba) << endl;

    return 0;
}


//----------------------- GRUPA B ---------------------------------

#include <iostream>
#include <fstream> // Dodajemy plik nagłówkowy do obsługi plików
#include <cmath>

// ---------- ZADANIE 1: miejsca zerowe ----------

// Funkcja wyznaczająca miejsce zerowego funkcji metodą połowienia
double znajdzZero(double (*funkcja)(double), double lewy, double prawy, double epsilon = 1e-6) {
    if (funkcja(lewy) * funkcja(prawy) > 0) {
        std::cerr << "Brak miejsca zerowego w podanym przedziale." << std::endl;
        return NAN;
    }

    while (prawy - lewy > epsilon) {
        double srodek = (lewy + prawy) / 2;
        if (funkcja(srodek) == 0) {
            std::cout << "Znalezione miejsce zerowe funkcji: " << srodek << std::endl;
            return srodek;
        }
        else if (funkcja(srodek) * funkcja(lewy) < 0)
            prawy = srodek;
        else
            lewy = srodek;
    }
    double miejsceZerowe = (lewy + prawy) / 2;
    std::cout << "Znalezione miejsce zerowe funkcji: " << miejsceZerowe << std::endl;
    return miejsceZerowe;
}

// Przykładowa funkcja kwadratowa
double funkcjaKwadratowa(double x) {
    return x * x - 4;
}


// ---------- ZADANIE 2: Implementacja stosu (from scratch) ----------
class Stos {
private:
    int* tablica;
    int pojemnosc;
    int indeksGorny;
public:
    Stos(int rozmiar) : pojemnosc(rozmiar), indeksGorny(-1) {
        tablica = new int[rozmiar];
    }

    void dodaj(int wartosc) {
        if (indeksGorny == pojemnosc - 1) {
            std::cerr << "Przepelnienie stosu!" << std::endl;
            return;
        }
        tablica[++indeksGorny] = wartosc;
    }

    void usun() {
        if (indeksGorny == -1) {
            std::cerr << "Niedomiar stosu!" << std::endl;
            return;
        }
        --indeksGorny;
    }

    void wyswietl() {
        for (int i = 0; i <= indeksGorny; ++i) {
            std::cout << tablica[i] << " ";
        }
        std::cout << std::endl;
    }

    ~Stos() {
        delete[] tablica;
    }
};

// ---------- ZADANIE 3: Implementacja listy dwukierunkowej ----------
struct Wezel {
    int wartosc;
    Wezel* poprzedni;
    Wezel* nastepny;
    
    Wezel(int value) : wartosc(value), poprzedni(nullptr), nastepny(nullptr) {}
};

class ListaDwukierunkowa {
private:
    Wezel* glowa;
    Wezel* ogon;
public:
    ListaDwukierunkowa() : glowa(nullptr), ogon(nullptr) {}

    void dodajZPliku(const std::string& nazwaPliku) {
        std::ifstream plik(nazwaPliku);
        if (!plik.is_open()) {
            std::cerr << "Nie mozna otworzyc pliku: " << nazwaPliku << std::endl;
            return;
        }

        int wartosc;
        while (plik >> wartosc) {
            dodajPosortowane(wartosc);
            char przecinek;
            plik >> przecinek; // Pomijanie przecinka
        }
        plik.close();
    }

    void dodajPosortowane(int wartosc) {
        Wezel* nowyWezel = new Wezel(wartosc);
        if (!glowa) {
            glowa = nowyWezel;
            ogon = nowyWezel;
            return;
        }

        if (wartosc <= glowa->wartosc) {
            nowyWezel->nastepny = glowa;
            glowa->poprzedni = nowyWezel;
            glowa = nowyWezel;
            return;
        }

        Wezel* aktualny = glowa;
        while (aktualny->nastepny && aktualny->nastepny->wartosc < wartosc) {
            aktualny = aktualny->nastepny;
        }

        if (!aktualny->nastepny) {
            aktualny->nastepny = nowyWezel;
            nowyWezel->poprzedni = aktualny;
            ogon = nowyWezel;
        } else {
            nowyWezel->nastepny = aktualny->nastepny;
            aktualny->nastepny->poprzedni = nowyWezel;
            aktualny->nastepny = nowyWezel;
            nowyWezel->poprzedni = aktualny;
        }
    }

    void usun(int wartosc) {
        Wezel* aktualny = glowa;
        while (aktualny) {
            if (aktualny->wartosc == wartosc) {
                if (aktualny == glowa) {
                    glowa = glowa->nastepny;
                    if (glowa)
                        glowa->poprzedni = nullptr;
                } else if (aktualny == ogon) {
                    ogon = ogon->poprzedni;
                    if (ogon)
                        ogon->nastepny = nullptr;
                } else {
                    aktualny->poprzedni->nastepny = aktualny->nastepny;
                    aktualny->nastepny->poprzedni = aktualny->poprzedni;
                }
                delete aktualny;
                return;
            }
            aktualny = aktualny->nastepny;
        }
        std::cerr << "Element " << wartosc << " nie zostal znaleziony na liscie." << std::endl;
    }

    void wyswietl() {
        Wezel* aktualny = glowa;
        while (aktualny) {
            std::cout << aktualny->wartosc << " ";
            aktualny = aktualny->nastepny;
        }
        std::cout << std::endl;
    }

    ~ListaDwukierunkowa() {
        Wezel* aktualny = glowa;
        while (aktualny) {
            Wezel* nastepny = aktualny->nastepny;
            delete aktualny;
            aktualny = nastepny;
        }
    }
};

// ---------- MAIN: Przykładowe użycie metod i struktur danych ----------
int main() {
    // ZADANIE 1: Wyznaczanie miejsc zerowych funkcji metodą połowienia
    std::cout << "ZADANIE 1: Wyznaczanie miejsc zerowych funkcji" << std::endl;
    std::cout << "Znalezienie miejsca zerowego funkcji kwadratowej x^2 - 4: ";
    znajdzZero(funkcjaKwadratowa, 0, 3);

    // ZADANIE 2: Implementacja stosu (from scratch)
    std::cout << "\nZADANIE 2: Implementacja stosu (from scratch)" << std::endl;
    Stos stos(5);
    stos.dodaj(1);
    stos.dodaj(2);
    stos.dodaj(3);
    std::cout << "Stos: ";
    stos.wyswietl();
    stos.usun();
    std::cout << "Stos po usunieciu: ";
    stos.wyswietl();

    // ZADANIE 3: Implementacja listy dwukierunkowej
    std::cout << "\nZADANIE 3: Implementacja listy dwukierunkowej" << std::endl;
    ListaDwukierunkowa lista;
    lista.dodajPosortowane(3);
    lista.dodajPosortowane(1);
    lista.dodajPosortowane(2);
    std::cout << "Lista: ";
    lista.wyswietl();
    lista.usun(2);
    std::cout << "Lista po usunieciu: ";
    lista.wyswietl();

    lista.dodajZPliku("dane.txt");
    std::cout << "Lista po dodaniu elementow z pliku: ";
    lista.wyswietl();

    return 0;
}