c++ sudetingiausia

#pragma warning(disable:4786)
#include <iostream>
#include <set>
#include <iomanip>
#include <string>
#include <fstream>
#include <cstdlib>
#include <vector>

using namespace std;

void meniu();
void isvalyti_ekrana_ir_rodyti_meniu();
void baigti();
int iveda_teksta_is_failo(string, vector<string> &);
void spausdinti_teksta(ostream &duomenys, vector<string> &);
void randa_ilgiausia_eilute(vector<string> &, int &);
void randa_trumpiausia_eilute(vector<string> &, int &);
int gauti_eilutes_ilgi(vector<string>, int);
void gauna_eiluciu_vidurkis(vector<string>, double &);
bool ar_antro_zodzio_trecia_raide_didzioji(string);
void suskaiciuoti_kiek_eilutej_yra_zodziu_prasidedanciu_mazaja_raide(string, int &);
int kiekis(string);
vector<string> explode( const string &delimiter, const string &str);
string& str_replace(const string &search, const string &replace, string &subject);
void sukeiciam_ilgiausia_ir_trumiausia_zodi(string &);
int kiek_tekste_yra_lotynisku_raidziu(vector<string> &, char);
void spausdinti_skaicius_arba_raides(vector<string> &, char, string & );
bool in_array(const char &needle, const vector< char > &haystack);
int gauti_eiluteje_esanciu_zodziu_kieki(string);
void pasalinti_pirma_didziaja_raide_prasidedanti_zodi(string &);
void prideti_zodi(string &, int, string);

int main(){

    // kintamuju aprasai
    bool veiksmas_egzistuoja = false;
    bool tekstas_ivestas = false;
    int veiksmas = -1;
    vector<string> tekstas;
    string vartotojo_zodis;
    string tekstas_spausdinimui;
    string kelias;
    int ilgiausia_eilute = -1;
    int trumpiausia_eilute = -1;
    int ilgiausios_eilutes_ilgis = -1;
    int trumpiausios_eilutes_ilgis = -1;
    int skaicius_int, sk_in_2; // iveda vartotojas 2 uzduociai
    double skaicius; // iveda vartotojas 1 uzduociai
    double eiluciu_vidurkis; // visu eiluciu ilgiu vidurkis
    int suma;
    int zodziu_kiekis;
    int did_lot_raidziu_kiekis, maz_lot_raidziu_kiekis;
    int kiek_eiluteje_yra_zodziu;

    cout << "Laboratorinis darbas nr. 4, Lukas Liesis, GM080102\n\n";
    cout << "Programa atlieka ivairius veiksmus su tekstu pagal vartotojo pasirinkima\n";
    cout << "Tekstas ivedamas is failo\n";

    // meniu spausdinimas

    meniu();
    // pagrindinis programos ciklas
    do {

        veiksmas_egzistuoja = false;
        cout << "\nIveskite norimo atlikti veiksmo meniu numeri: ";
        cin >> veiksmas;
        cout << "\n";

        switch ( veiksmas ) {

            case 0 :
                meniu();
                break;
            case 1 :
                isvalyti_ekrana_ir_rodyti_meniu();
                break;
            case 2 :
                baigti();
                break;
            case 3 :
                cout << "Nurodykite kelia iki failo: ";
                cin >> kelias;
                if(iveda_teksta_is_failo(kelias, tekstas) == -1){
                    cout << "Klaida! Netinkamas failas arba kelias iki jo.\n";
                } else {
                    tekstas_ivestas = true;
                    ilgiausia_eilute = -1;
                    trumpiausia_eilute = -1;
                }
                break;
            case 4 :
                if(tekstas_ivestas == false){
                    cout << "Klaida! Teksto nera\n";
                } else {
                    spausdinti_teksta(cout, tekstas);
                }
                break;
            case 5 :
                /*
                Jeigu ilgiausios ir trumpiausios eilučių ilgių suma yra didesnė už vartotojo nurodytą skaičių,
                suskaičiuokite ir atspausdinkite tekste esančių eilučių kiekį ir vidutinį jų ilgį.
                */
                if(tekstas_ivestas == false){
                    cout << "Klaida! Neivestas tekstas\n";
                    break;
                }
                randa_ilgiausia_eilute(tekstas, ilgiausia_eilute);
                randa_trumpiausia_eilute(tekstas, trumpiausia_eilute);
                ilgiausios_eilutes_ilgis = gauti_eilutes_ilgi(tekstas, ilgiausia_eilute);
                trumpiausios_eilutes_ilgis = gauti_eilutes_ilgi(tekstas, trumpiausia_eilute);

                cout << "Ilgiausia eilute yra: " << ilgiausia_eilute+1 << " jos ilgis: " << ilgiausios_eilutes_ilgis << "\n";
                cout << "Trumpiausia eilute yra: " << trumpiausia_eilute+1 << " jos ilgis: " << trumpiausios_eilutes_ilgis << "\n";
                suma = ilgiausios_eilutes_ilgis+trumpiausios_eilutes_ilgis;
                cout << "Ju suma yra " << suma << "\n";
                cout << "\nNuorodykite skaiciu: \n";
                cin >> skaicius; // double
                if (cin.fail()) {// jei ivesti neteisingi duomenys, sutvarkom cina ir pranesam apie klaida
                    cin.clear();
                    cin.ignore(256, '\n');
                    cout << "Klaida! Neteisinga ivestis\n";
                }
                if(suma > skaicius ){
                    gauna_eiluciu_vidurkis(tekstas, eiluciu_vidurkis);
                    cout << "Suma yra didesne uz ivestas skaiciu.\n";
                    cout << "Tekste esanciu eiluciu kiekis: \t" << tekstas.size() << "\n";
                    cout << "Eiluciu ilgiu vidurkis: \t" << eiluciu_vidurkis << "\n";
                } else {
                    cout << "Suma yra mazesne uz ivesta skaiciu. Nieko nedarome. \n";
                }
                cout << "\n";
                break;
            case 6 :
                /*
                Jeigu nagrinėjamos eilutės antro žodžio trečia raidė didžioji, suskaičiuokite, kiek joje yra žodžių,
                prasidedančių mažąja raide. Kitu atveju sukeiskite trumpiausią ir ilgiausią tos eilutės žodžius vietomis.
                */
                cout << "Eiluciu yra: " << tekstas.size() << "\n";
                cout << "Nuordykite kuria eilute nagrinejame: ";
                cin >> skaicius_int;
                if (cin.fail()) {// jei ivesti neteisingi duomenys, sutvarkom cina ir pranesam apie klaida
                    cin.clear();
                    cin.ignore(256, '\n');
                    cout << "Klaida! Neteisinga ivestis\n";
                }
                if(skaicius_int > tekstas.size()){
                    cout << "Klaida! Tokios eilutes nera. \n";
                } else {
                    cout << "Nagrinejama eilute: \n\n" << tekstas[skaicius_int-1] << "\n\n";
                    if(ar_antro_zodzio_trecia_raide_didzioji(tekstas[skaicius_int-1])){ // !!!!!!!!!!!
                        cout << "Taip, 2 zodzio 3 raide yra didzioji.\n";
                        zodziu_kiekis = 0;
                        suskaiciuoti_kiek_eilutej_yra_zodziu_prasidedanciu_mazaja_raide(tekstas[skaicius_int-1], zodziu_kiekis); //!!!!!!!!!
                        cout << "Sioje eiluteje yra zodziu, kurie prasideda mazaja raide: " << zodziu_kiekis << "\n";
                    } else {
                        cout << "Ne, 2 zodzio 3 raide nera didzioji.\n";
                        cout << "Sukeiciame ilgiausia ir trumpiausia zodzius vietomis. Nauja eilute yra: \n\n";
                        sukeiciam_ilgiausia_ir_trumiausia_zodi(tekstas[skaicius_int-1]);
                        cout << "\n" << tekstas[skaicius_int-1] << "\n\n";
                    }
                }
                break;
            case 7 :
                did_lot_raidziu_kiekis = kiek_tekste_yra_lotynisku_raidziu(tekstas, 'd');
                cout << "Lotynisku didziuju raidziu tekste yra: " << did_lot_raidziu_kiekis << "\n";
                maz_lot_raidziu_kiekis = kiek_tekste_yra_lotynisku_raidziu(tekstas, 'm');
                cout << "Lotynisku mazuju raidziu tekste yra: " << maz_lot_raidziu_kiekis << "\n";
                if(did_lot_raidziu_kiekis > maz_lot_raidziu_kiekis){
                    cout << "Didziuju raidziu yra daugiau uz mazuju, jos yra: \n";
                    spausdinti_skaicius_arba_raides(tekstas, 'r', tekstas_spausdinimui);
                    cout << tekstas_spausdinimui << "\n";
                } else {
                    spausdinti_skaicius_arba_raides(tekstas, 's', tekstas_spausdinimui);
                    cout << "Didziuju raidziu yra maziau uz mazuju, skaiciai tekste yra: \n";
                    cout << tekstas_spausdinimui << "\n";
                }

                break;
            case 8 :
                // Jeigu eiluteje esanèiu žodžiu skaièius didesnis už vartotojo nurodyt¹ skaièiu, pašalinkite joje
                //esanti pirm¹ji didžiaja raide prasidedanti žodi. Kitu atveju po
                //vartotojo nurodyto žodžio toje eiluteje (nurodomas žodžio eiles numeris) iterpkite vartotojo ivest¹ žodi.
                cout << "Nurodykite kuria eilute norite nagrineti: \n";
                cin >> sk_in_2;
                if (cin.fail()) {// jei ivesti neteisingi duomenys, sutvarkom cina ir pranesam apie klaida
                    cin.clear();
                    cin.ignore(256, '\n');
                    cout << "Klaida! Neteisinga ivestis\n";
                }
                if(sk_in_2 < 1){
                    cout << "Klaida! Neteisinga ivestis \n";
                    break;
                }

                cout << "Pasirinkta eilute: \n";
                cout << tekstas[sk_in_2-1];

                kiek_eiluteje_yra_zodziu = gauti_eiluteje_esanciu_zodziu_kieki(tekstas[sk_in_2-1]);
                cout << "eiluteje yra zodziu: " << kiek_eiluteje_yra_zodziu << "\n";
                cout << "Iveskite koki nors sveikaji skaiciu > 0: \n";
                cin >> skaicius_int;
                if (cin.fail()) {// jei ivesti neteisingi duomenys, sutvarkom cina ir pranesam apie klaida
                    cin.clear();
                    cin.ignore(256, '\n');
                    cout << "Klaida! Neteisinga ivestis\n";
                }
                if(skaicius_int < 0){
                    cout << "Klaida! Neteisinga ivestis \n";
                    break;
                }
                if(kiek_eiluteje_yra_zodziu < skaicius_int){
                    // pasalinti pirma didziaja raide prasidedanti zodi
                    pasalinti_pirma_didziaja_raide_prasidedanti_zodi(tekstas[sk_in_2-1]);
                    cout << "Zodis pasalintas. Nauja eilute yra: \n";
                    cout << tekstas[sk_in_2-1];
                } else {
                    // vartotojo zodi ivesti i ta vieta, kur nurode pries tai
                    cin.clear();
                    cin.ignore(256, '\n');
                    cout << "Iveskite zodi: \n";
                    cin >> vartotojo_zodis;
                    if (cin.fail()) {// jei ivesti neteisingi duomenys, sutvarkom cina ir pranesam apie klaida
                        cin.clear();
                        cin.ignore(256, '\n');
                        cout << "Klaida! Neteisinga ivestis\n";
                    }
                    cout << "Ivestas zodis: " << vartotojo_zodis << "\n";
                    prideti_zodi(tekstas[sk_in_2-1], skaicius_int ,vartotojo_zodis);
                    cout << "Zodis pridetas. Nauja eilute yra: \n";
                    cout << tekstas[sk_in_2-1];
                }

                break;

            default :
                cout << "Tokio meniu punkto nera. Pasirinkite nauja veiksma.\n";
                meniu();

        }


        if (cin.fail()) {// jei ivesti neteisingi duomenys, sutvarkom cina ir pranesam apie klaida
            cin.clear();
            cin.ignore(256, '\n');
            cout << "Klaida! Neteisingi parametrai\n";
        }

    } while(true);  // ciklas vyksta visa programos veikimo laika
    return 0;
}

// parodo meniu

void meniu() {
    cout << "[0] Meniu\n";
    cout << "[1] Isvalyti ekrana ir rodyti meniu\n";
    cout << "[2] Baigti darba\n";
    cout << "[3] Ivesti teksta\n";
    cout << "[4] Spausdinti teksta\n";
    cout << "[5] 1 uzduotis\n";
    cout << "[6] 2 uzduotis\n";
    cout << "[7] pradine uzduotis su lot. raidemis\n";
    cout << "[8] 3 uzduotis\n";

    cout << "\n\n\n";
}

// baigia darba

void baigti() {
    exit(0);
}

// isvalo ekrana ir parodo meniu

void isvalyti_ekrana_ir_rodyti_meniu(){
    system("cls");
    meniu();
}

// iveda teksta is nurodyto failo

int iveda_teksta_is_failo(string kelias, vector<string> & tekstas ){
    ifstream skaito( kelias );
    if(skaito.fail()){
        return -1;
    }
    string temp;

    tekstas.clear();
    // po 1 eilute nuskaito teksta
    while( getline( skaito, temp ) ){
        tekstas.push_back( temp );
    }
}

// spausdina teksta i ekrana arba faila

void spausdinti_teksta(ostream &duomenys, vector<string> & tekstas){
    int ilgis = tekstas.size();
    for(int i = 0; i < ilgis; i++) {
        duomenys << tekstas[i];
        duomenys << "\n"; // pereina i nauja eilute
    }
}


void randa_ilgiausia_eilute(vector<string> & tekstas, int & ilgiausia_eilute){
    ilgiausia_eilute = 0;
    int ilgis = tekstas.size();
    for(int i = 0; i < ilgis; i++) {
        if(tekstas[i].size() > tekstas[ilgiausia_eilute].size()){
            ilgiausia_eilute = i;
        }
    }
}


void randa_trumpiausia_eilute(vector<string> & tekstas, int & trumpiausia_eilute){
    trumpiausia_eilute = 0;
    int ilgis = tekstas.size();
    for(int i = 0; i < ilgis; i++) {
        if(tekstas[i].size() < tekstas[trumpiausia_eilute].size()){
            trumpiausia_eilute = i;
        }
    }
}

int gauti_eilutes_ilgi(vector<string> tekstas, int eilute){
    return tekstas[eilute].size();
}

void gauna_eiluciu_vidurkis(vector<string> tekstas, double & vidurkis) {
    vidurkis = 0;
    double suma = 0.;
    int ilgis = tekstas.size();
    for(int i = 0; i < ilgis; i++) {
        suma += tekstas[i].size();
    }
    vidurkis = suma / ilgis;
}

bool ar_antro_zodzio_trecia_raide_didzioji(string eilute) {
    vector<string> zodziu_masyvas;
    zodziu_masyvas = explode(" ", eilute);
    if(zodziu_masyvas.size() > 1){
        if( (zodziu_masyvas[1][2] == ',') || (zodziu_masyvas[1][2] == '.') ){
            return false;
        }
        if(isupper(zodziu_masyvas[1][2])){
            return true;
        }
    }

    return false;
}

void suskaiciuoti_kiek_eilutej_yra_zodziu_prasidedanciu_mazaja_raide(string eilute, int & zodziu_kiekis){
    vector<string> zodziu_masyvas;
    zodziu_masyvas = explode(" ", eilute);
    zodziu_kiekis = 0;
    if(zodziu_masyvas.size() > 0){
        int ilgis = zodziu_masyvas.size();
        for(int i = 0; i < ilgis; i++) {
            if(islower(zodziu_masyvas[i][0])){
                zodziu_kiekis++;
            }
        }
    }
}

int kiekis(string eilute) {
    int i, j=0, k=0;
    for(i = 0; i < sizeof(eilute.length()); i++){
        if(eilute[i] == ' '){
            k += 1;
        } else {
            j += 1;
        }
    }
    if (j>0) {
        return k+1;
    } else {
        return k;
    }
}



string& str_replace(const string &search, const string &replace, string &subject) {
    string buffer;

    int sealeng = search.length();
    int strleng = subject.length();

    if (sealeng==0)
        return subject;//no change

    for(int i=0, j=0; i<strleng; j=0 ) {
        while (i+j<strleng && j<sealeng && subject[i+j]==search[j])
            j++;
        if (j==sealeng) { //found 'search'
            buffer.append(replace);
            i+=sealeng;
        } else {
            buffer.append( &subject[i++], 1);
        }
    }
    subject = buffer;
    return subject;
}

vector<string> explode( const string &delimiter, const string &str) {
    vector<string> arr;

    int strleng = str.length();
    int delleng = delimiter.length();
    if (delleng==0)
        return arr;//no change

    int i=0;
    int k=0;
    while( i<strleng ) {
        int j=0;
        while (i+j<strleng && j<delleng && str[i+j]==delimiter[j])
            j++;
        if (j==delleng) { //found delimiter
            arr.push_back(  str.substr(k, i-k) );
            i+=delleng;
            k=i;
        } else {
            i++;
        }
    }
    arr.push_back(  str.substr(k, i-k) );
    return arr;
}

void sukeiciam_ilgiausia_ir_trumiausia_zodi(string & eilute){
    vector<string> zodziu_masyvas;
    vector<string> zodziu_masyvas_backup;   // backupo reikia, nes zodziu_masyva sudraskytas bus del . ir ,
    zodziu_masyvas = explode(" ", eilute);
    zodziu_masyvas_backup = zodziu_masyvas;
    if(zodziu_masyvas.size() > 0){
        int ilgis = zodziu_masyvas.size();
        // randa trumpiausia ir ilgiausia zodzius
        int trumpiausias = 0;
        int ilgiausias = 0;
        for(int i = 0; i < ilgis; i++) {
            zodziu_masyvas[i] = str_replace(",", "", zodziu_masyvas[i]);
            zodziu_masyvas[i] = str_replace(".", "", zodziu_masyvas[i]);
            zodziu_masyvas[i] = str_replace(" ", "", zodziu_masyvas[i]);
            if(isalpha(zodziu_masyvas[i][0])){
                if(zodziu_masyvas[i].size() < zodziu_masyvas[trumpiausias].size()){
                    trumpiausias = i;
                }
                if(zodziu_masyvas[i].size() > zodziu_masyvas[ilgiausias].size()){
                    ilgiausias = i;
                }
            }
        }
        // apkeicia vietomis
        string buffer =  zodziu_masyvas_backup[trumpiausias];
        zodziu_masyvas_backup[trumpiausias] = zodziu_masyvas_backup[ilgiausias];
        zodziu_masyvas_backup[ilgiausias] = buffer;
        bool pirmas = true;
        string nauja_eilute;
        for(int i = 0; i < ilgis; i++) {
            if(pirmas){
                nauja_eilute.append(zodziu_masyvas_backup[i]);
            } else {
                nauja_eilute.append(" ");
                nauja_eilute.append(zodziu_masyvas_backup[i]);
            }
            pirmas = false;
        }
        eilute = nauja_eilute;
    }
}


int kiek_tekste_yra_lotynisku_raidziu(vector<string> & tekstas, char tipas){
    int eiluciu = tekstas.size();
    int eilute = 0;
    int kiek_yra_didziuju = 0;
    for(int i = 0; i < eiluciu; i++){
        eilute = tekstas[i].size();
        for(int j = 0;j < eilute; j++ ){
            if(tipas == 'd'){
                if( isalpha(tekstas[i][j]) && isupper(tekstas[i][j]) ){
                    kiek_yra_didziuju++;
                }
            } else {
                if( isalpha(tekstas[i][j]) && islower(tekstas[i][j]) ){
                    kiek_yra_didziuju++;
                }
            }
        }
    }

    return kiek_yra_didziuju;
}

void spausdinti_skaicius_arba_raides(vector<string> & tekstas, char tipas, string & tekstas_atgal){
    vector<char> masyvas_raidziu;
    vector<char> masyvas_skaiciu;

    tekstas_atgal = "";
    int eiluciu = tekstas.size();
    int eilute = 0;
    int kiek_yra_didziuju = 0;
    for(int i = 0; i < eiluciu; i++){
        eilute = tekstas[i].size();
        for(int j = 0;j < eilute; j++ ){
            if(tipas == 'r'){
                // spausdina lot. did. raides
                if( isalpha(tekstas[i][j]) && isupper(tekstas[i][j]) ){
                    if(in_array(tekstas[i][j], masyvas_raidziu) == false){
                        tekstas_atgal += tekstas[i][j];
                        masyvas_raidziu.push_back(tekstas[i][j]);
                    }
                }
            } else {
                if( isdigit(tekstas[i][j])){
                    if(in_array(tekstas[i][j], masyvas_skaiciu) == false){
                        tekstas_atgal += tekstas[i][j];
                        masyvas_skaiciu.push_back(tekstas[i][j]);
                    }
                }
            }
        }
    }
}

bool in_array(const char &needle, const vector< char > &haystack){
    int max=haystack.size();
    if (max==0) return false;
    for(int i=0; i<max; i++)
        if (haystack[i]==needle)
            return true;
    return false;
}

int gauti_eiluteje_esanciu_zodziu_kieki(string eilute){
    vector<string> zodziu_masyvas;
    zodziu_masyvas = explode(" ", eilute);
    return zodziu_masyvas.size();
}


void pasalinti_pirma_didziaja_raide_prasidedanti_zodi(string & eilute){
    vector<string> zodziu_masyvas;
    vector<string> zodziu_masyvas_backup;
    zodziu_masyvas = explode(" ", eilute);
    zodziu_masyvas_backup = zodziu_masyvas;
    eilute = "";
    int kuri_salint = 0;
    if(zodziu_masyvas.size() > 0){
        int ilgis = zodziu_masyvas.size();
        cout << "ilgis: "<<ilgis << "\n";
         // dsa adsdsa asd Aasdad Aasdads dads
        for(int i = 0; i < ilgis-1; i++) {
            zodziu_masyvas[i] = str_replace(",", "", zodziu_masyvas[i]);
            zodziu_masyvas[i] = str_replace(".", "", zodziu_masyvas[i]);
            zodziu_masyvas[i] = str_replace(" ", "", zodziu_masyvas[i]);
            if(isalpha(zodziu_masyvas[i][0]) && isupper(zodziu_masyvas[i][0]) ){
                kuri_salint = i;
                break;
            }
        }
        // istrina
        ilgis = zodziu_masyvas_backup.size();
        cout << "kuri salint: " << kuri_salint << "ilgis: " << ilgis << "\n";
        bool pirmas = true;
        for(int i = 0; i < ilgis; i++) {
            if(i != kuri_salint){
                if(pirmas){
                    eilute = zodziu_masyvas_backup[i];
                } else {
                    eilute += " "+zodziu_masyvas_backup[i];
                }
                pirmas = false;
            }
        }
    }


}

void prideti_zodi(string & eilute, int kur_iterpt, string ka_iterpt){
    //cout << "kur iterpt: "<< kur_iterpt << " ka_iterpt: "<<ka_iterpt<<"\n";
    vector<string> zodziu_masyvas;
    vector<string> zodziu_masyvas_backup;
    zodziu_masyvas = explode(" ", eilute);
    zodziu_masyvas_backup = zodziu_masyvas;
    eilute = "";
    int kelintas_cia_zodis = 0;
    int indeksas_pries_kuri_iterpt;
    if(zodziu_masyvas.size() > 0) {
        int ilgis = zodziu_masyvas.size();
        for(int i = 0; i < ilgis-1; i++) {
            zodziu_masyvas[i] = str_replace(",", "", zodziu_masyvas[i]);
            zodziu_masyvas[i] = str_replace(".", "", zodziu_masyvas[i]);
            zodziu_masyvas[i] = str_replace(" ", "", zodziu_masyvas[i]);
            if(isalpha(zodziu_masyvas[i][0]) ){
                kelintas_cia_zodis++;
                if(kelintas_cia_zodis == kur_iterpt){
                    indeksas_pries_kuri_iterpt = i;
                }
            }
        }
        // iterpia
        ilgis = zodziu_masyvas_backup.size();
        //cout << "pries kuri iterpt: " << indeksas_pries_kuri_iterpt << "ilgis: " << ilgis << "\n";
        eilute = "";
        bool pirmas = true;
        for(int i = 0; i < ilgis; i++) {
            if(i == indeksas_pries_kuri_iterpt){
                if(!pirmas){
                    eilute += " ";
                }
                pirmas = false;
                eilute += ka_iterpt;
            }
            if(!pirmas){
                eilute += " ";
            }
            pirmas = false;

            eilute += zodziu_masyvas_backup[i];
        }
    }
}