# Masyvai

# Apie masyvus

Masyvus galima įsivaizduoti kaip:

Masyvas yra specialaus tipo kintamasis, kuris gali saugoti daugiau nei vieną reikšmę.
Masyvas apjungia kelis skirtingus kintamuosius į vieną vietą.
Masyvai skirti apjungti (ar sugrupuoti) kelis to pačio tipo kintamuosius į vieną vietą.
Masyvas padeda sugrupuoti susijusius duomenis.

# Kuo masyvai gali būti naudingi?

Lengviau manipuliuoti didesniais informacijos kiekiais:
- Visi susiję duomenys yra sugrupuoti ir pasiekiami per vieną kintamojo pavadinimą, todėl norint atlikti kokius nors veiksmus, galima viską pasiekti vienoje vietoje. Taip pat, galima naudoti ciklus, kurie automatiškai pereitų per visus turimus duomenis, o ne rankiniu būdu nurodyti skirtingus kintamuosius.
Kodas tampa tvarkingesnis ir lengviau skaitomas:
- Kadangi duomenys būna sugrupuoti ir pasiekiami per vieną pavadinimą, nereikia įsiminti kelių skirtingų pavadinimų norint pasiekti duomenis. Taip pat, yra užrašoma mažiau kodo, vietoj to, kad kurti daug skirtingų kintamųjų, kiekvienam jų atskirai nurodant reikšmes, galima sukurti vieną kintamąjį ir jam visas reikalingas reikšmes priskirti per kablelį.

# Kur naudojami masyvai?

Jie naudojami visur kur yra bent kiek daugiau, susijusių duomenų. Pavyzdžiui:
- Studento turimi pažymiai.
- Automobilių markės.
- Žmonių vardai.
- Darbuotojų algos.
- Ar objektų masyvai. Pavyzdžiui: visų darbuotojų informacija (jų vardai, pavardės, algos, pareigos ir t. t.).
Kai turime visus duomenis masyvuose, juos lengva panaudoti. Pavyzdžiui:
- Visus duomenis lengvai ir greitai atspausdinti.
- Atlikti tam tikrus skaičiavimus ar veiksmus su visais ar pasirinktais masyvo elementais. Pavyzdžiui, surūšiuoti prekes pagal kainą ar rasti studentų pažymių vidurkį.
- Paimti tam tikrą, reikalingą elementą iš masyvo, pavyzdžiui tam tikrą prekę ir atvaizduoti tai kas susiję su ja.
- ...

# Masyvų tipai

Vienmačiai.
Daugiamačiai (dvimačiai, trimačiai, ...).

# Vienmačiai masyvai

# Apie vienmatį masyvą

Masyve saugoma tik viena eilė susijusių duomenų. Pavyzdžiui, vienas po kito einantys:
- pažymiai;
- vardai;
- automobilių markės;
- ūgiai;
- kiekvienos dienos temperatūros;
- ...
Viename vienmatyje masyve saugoma tokio paties duomenų tipo informacija (tik int, tik string, ar pan.).
Kuriant masyvą reikia nurodyti masyvo dydį (kiek maksimaliai elementų bus saugoma jame). Vietoj to galima masyvui iškart priskirti duomenys, dėl ko jo dydis bus paskaičiuojamas automatiškai.
Sukūrus norimo dydžio masyvą, jo viso užpildyti nebūtina, tačiau geriau jį kurti tokio dydžio, kad kuo labiau būtų išnaudojama visa rezervuota vieta, nes kitu atveju - tai tik atmintyje rezervuota ir nepanaudota vieta.
Masyvo dydžio pakeisti programos eigoje negalima.
Masyve esančius duomenis pasiekti ar keisti programos eigoje galima.

# Vienmačio masyvo sintaksė

Tuščias, nurodyto dydžio masyvas:

<tipas> <pavadinimas>[<dydis>];

Masyvas, kūrimo metu užpildytas su nurodytais duomenimis:

<tipas> <pavadinimas>[] = { <duomenys> };

Paaiškinimai:

tipas - kokio tipo duomenys bus šiame masyve (int, string, char, float, ...).
pavadinimas - koks masyvo pavadinimas / vardas, apibūdinantis kokią informaciją jis saugo, kaip jį galima pasiekti programoje.
dydis - kiek maksimaliai elementų bus saugoma jame, pavyzdžiui, dešimt pažymių.
duomenys - reikšmės duomenų, kurios įrašomos masyvo kūrimo metu.

# Masyvo narių indeksavimas

# Pavyzdys 1

Duomenys ir jų indeksai:

Reikšmė:	5	8	9	2	-1	7	-2	4
Indeksas:	0	1	2	3	4	5	6	7

Aprašymas per kodą:

int skaiciai[] = { 5, 8, 9, 2, -1, 7, -2, 4 };

# Pavyzdys 2

Duomenys ir jų indeksai:

Reikšmė:	Gluosnis	Ažuolas	Liepa	Berželis	Obelis
Indeksas:	0	1	2	3	4

Aprašymas per kodą:

string medziai[] =
{
  "Gluosnis",
  "Azuolas",
  "Liepa",
  "Berzelis",
  "Obelis"
};

# Pavyzdys 3

Duomenys ir jų indeksai:

Reikšmė:	7.5	8	4.5	9.8	7.6
Indeksas:	0	1	2	3	4

Aprašymas per kodą:

double pazymiai[] = { 7.5, 8, 4.5, 9.8, 7.6 };

# Duomenų pasiekimas per indeksą

Reikšmės pasiekimas (išspausdinimas):

cout << pavadinimas[indeksas];

Reikšmės pakeitimas:

pavadinimas[indeksas] = nauja_reiksme;

# Pasitikrinkite: koks indeksas, kokia reikšmė?

Reikšmė:	5	8	9	2	-1	7	-2	4
Indeksas:	0	1	2	3	4	5	6	7

skaiciai[???] = 5;
skaiciai[3] = ???;
skaiciai[6] = ???;
skaiciai[???] = 8;
skaiciai[???] = 7;
skaiciai[4] = ???;
skaiciai[???] = 9;
skaiciai[???] = 4;

# Masyvo dydis ir elementų kiekis

Masyvo dydis ir masyve esantis elementų kiekis nėra vienas ir tas pats.
Masyvas gali būti ir didesnis nei į jį yra įvesta informacijos.
C++ kalboje nėra automatinio length ar count sekimo, kuris nurodytų kiek elementų yra nurodytame masyve, todėl tai reikės daryti patiems.

Tarkime, sukuriame pažymių masyvą, kurio dydis yra 10 elementų:

int pazymiai[10];

Į šį masyvą įrašome 5 pažymius:

pazymiai[0] = 8;
pazymiai[1] = 9;
pazymiai[2] = 7;
pazymiai[3] = 10;
pazymiai[4] = 8;

Todėl dirbant su šio masyvo duomenimis mums reikės kažkaip žinoti, kiek duomenų jame iš tikrųjų yra. Tam tikslui galime įsivesti int tipo kintamąjį, kuris saugotų šį kiekį:

int pazymiu_kiekis = 5;

Šis masyvas atmintyje atrodytų kažkaip panašiai:

Reikšmė:	8	9	7	10	8	-	-	-	-	-
Indeksas:	0	1	2	3	4	5	6	7	8	9

# Vienmačiai masyvai: informacijos įvedimas ir gavimas (išvedimas)

# Pavyzdžiai

# Pavyzdys 1

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Masyvo sukūrimas
    int pazymiai[] = {8, 7, 9, 10, 6, 8};

    // Kiek masyve yra elementų
    int pazymiu_kiekis = 6;

    // Masyvo išvedimas
    for (int i = 0; i < pazymiu_kiekis; i++)
    {
        cout << pazymiai[i] << endl;
    }

    return 0;
}

Rezultatai:

# Pavyzdys 2

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Masyvo sukūrimas, kurio dydis yra 5
    int pazymiai[5];

    // Masyvo užpildymas reikšmėmis
    pazymiai[0] = 8;
    pazymiai[1] = 7;
    pazymiai[2] = 9;
    pazymiai[3] = 10;
    pazymiai[4] = 6;

    // Kiek masyve yra elementų
    int pazymiu_kiekis = 5;

    // Masyvo išvedimas
    for (int i = 0; i < pazymiu_kiekis; i++)
    {
        cout << pazymiai[i] << " ";
    }
    cout << endl;

    return 0;
}

Rezultatai:

8 7 9 10 6

# Pavyzdys 3

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Masyvo sukūrimas, kurio dydis yra 5
    int pazymiai[5];

    // Kiek masyve yra elementų
    int pazymiu_kiekis = 5;

    // Masyvo užpildymas reikšmėmis
    cout << "Iveskite 5 pazymius: ";
    cin >> pazymiai[0] >> pazymiai[1] >> pazymiai[2]
        >> pazymiai[3] >> pazymiai[4];

    // Masyvo išvedimas
    cout << "Ivesti pazymiai: ";
    for (int i = 0; i < pazymiu_kiekis; i++)
    {
        cout << pazymiai[i] << ", ";
    }
    cout << endl;

    return 0;
}

Rezultatas 1:

Iveskite 5 pazymius: 7 8 9 6 10
Ivesti pazymiai: 7, 8, 9, 6, 10,

Rezultatas 2:

Iveskite 5 pazymius: 8 7 5 1 4
Ivesti pazymiai: 8, 7, 5, 1, 4,

# Pavyzdys 4

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Masyvo sukūrimas, kurio dydis yra 5
    int pazymiai[5];

    // Kiek masyve yra elementų
    int pazymiu_kiekis = 5;

    // Masyvo užpildymas reikšmėmis
    cout << "Iveskite 5 pazymius: ";
    for (int i = 0; i < pazymiu_kiekis; i++)
    {
        cin >> pazymiai[i];
    }

    // Masyvo išvedimas
    cout << "Ivesti pazymiai: ";
    for (int i = 0; i < pazymiu_kiekis; i++)
    {
        cout << pazymiai[i] << ", ";
    }
    cout << endl;

    return 0;
}

Rezultatas 1:

Iveskite 5 pazymius: 8 7 5 6 3
Ivesti pazymiai: 8, 7, 5, 6, 3,

Rezultatas 2:

Iveskite 5 pazymius: 10 10 9 8 10
Ivesti pazymiai: 10, 10, 9, 8, 10,

# Pavyzdys 5

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Masyvo sukūrimas, kurio dydis yra 5
    int skaiciai[] = { 7, 8, 9, 7, 4, 5, 6, 8, 7, 5, 2, 3 };

    // Kiek masyve yra elementų
    int skaiciu_kiekis = 12;

    // Pirmas narys masyve
    cout << "Pirmas narys masyve: " << skaiciai[0] << endl;

    // Antras narys masyve
    cout << "Antras narys masyve: " << skaiciai[1] << endl;

    // Paskutinis narys masyve
    cout << "Paskutinis narys masyve: " << skaiciai[skaiciu_kiekis - 1] << endl;

    // Prieš paskutinis narys masyve
    cout << "Pries paskutinis narys masyve: " << skaiciai[skaiciu_kiekis - 2] << endl;

    return 0;
}

Rezultatai:

Pirmas narys masyve: 7
Antras narys masyve: 8
Paskutinis narys masyve: 3
Pries paskutinis narys masyve: 2

# Pavyzdys 6

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Pirmo skaičių masyvo sukūrimas
    int skaiciai1[] = { 7, 8, 9, 6, 5 };
    int skaiciai1_kiekis = 5;

    // Antro skaičių masyvo sukūrimas
    int skaiciai2[] = { 8, 5, 2, 3, 6, 4, 4 };
    int skaiciai2_kiekis = 7;

    // Pirmo skaičių masyvo išvedimas
    cout << "Pirmi skaiciai (" << skaiciai1_kiekis << "): ";

    for (int i = 0; i < skaiciai1_kiekis; i++)
    {
        cout << "[" << skaiciai1[i] << "]";
    }

    cout << endl;

    // Antro skaičių masyvo išvedimas
    cout << "Antri skaiciai (" << skaiciai2_kiekis << "): ";

    for (int i = 0; i < skaiciai2_kiekis; i++)
    {
        cout << "[" << skaiciai2[i] << "]";
    }

    cout << endl;

    return 0;
}

Rezultatai:

Pirmi skaiciai (5): [7][8][9][6][5]
Antri skaiciai (7): [8][5][2][3][6][4][4]

# Pavyzdys 7

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Skaičių masyvo sukūrimas
    int skaiciai[100];
    int skaiciai_kiekis = 0;

    // Klausiama kiek žmogus nori įvesti skaičių
    cout << "Kiek skaiciu norite ivesti? ";
    cin >> skaiciai_kiekis;

    // Žmogus įveda skaičius
    for (int i = 0; i < skaiciai_kiekis; i++)
    {
        cout << i + 1 << "-asis skaicius: ";
        cin >> skaiciai[i];
    }

    // Skaičiai išvedami į konsolę
    cout << "\nJusu ivesti skaiciai: ";

    for (int i = 0; i < skaiciai_kiekis; i++)
    {
        cout << "[" << skaiciai[i] << "]";
    }

    return 0;
}

Rezultatas 1:

Kiek skaiciu norite ivesti? 4
1-asis skaicius: 8
2-asis skaicius: 9
3-asis skaicius: 6
4-asis skaicius: 5

Jusu ivesti skaiciai: [8][9][6][5]

Rezultatas 2:

Kiek skaiciu norite ivesti? 9
1-asis skaicius: 8
2-asis skaicius: 5
3-asis skaicius: 6
4-asis skaicius: 8
5-asis skaicius: 7
6-asis skaicius: 5
7-asis skaicius: 2
8-asis skaicius: 3
9-asis skaicius: 4

Jusu ivesti skaiciai: [8][5][6][8][7][5][2][3][4]

# Pavyzdys 8

Kodas:

#include <iostream>
#include <iomanip>
#include <string>
using namespace std;

int main()
{
    // Sukuriami vardų ir amžių masyvai
    string vardai[10];
    int amziai[10];

    // Nurodomas įrašytų elementų kiekis šiuos masyvuose
    int kiekis = 0;

    // Užklausiama kiek bus įvedimų
    cout << "Kiek duomenu norite ivesti? ";
    cin >> kiekis;

    // Įvedinėjami duomenys
    for (int i = 0; i < kiekis; i++)
    {
        cout << i + 1 << "-asis zmogus\n";
        cout << "Vardas: ";
        cin >> vardai[i];
        cout << "Amzius: ";
        cin >> amziai[i];
    }

    // Duomenys išvedami iš šių dviejų masyvų

    cout << "\nIvesti duomenys\n\n";
    cout << "+----------------------+--------+\n";
    cout << "| Vardas               | Amzius |\n";
    cout << "+----------------------+--------+\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << "| " << setw(20) << left << vardai[i]
            << " | " << setw(6) << amziai[i] << " |" << endl;
    }

    cout << "+----------------------+--------+\n";

    return 0;
}

Rezultatas 1:

Kiek duomenu norite ivesti? 3
1-asis zmogus
Vardas: Jonas
Amzius: 74
2-asis zmogus
Vardas: Petras
Amzius: 15
3-asis zmogus
Vardas: Gintas
Amzius: 32

Ivesti duomenys

+----------------------+--------+
| Vardas               | Amzius |
+----------------------+--------+
| Jonas                | 74     |
| Petras               | 15     |
| Gintas               | 32     |
+----------------------+--------+

Rezultatas 2:

Kiek duomenu norite ivesti? 5
1-asis zmogus
Vardas: Greta
Amzius: 19
2-asis zmogus
Vardas: Gintare
Amzius: 20
3-asis zmogus
Vardas: Povilas
Amzius: 21
4-asis zmogus
Vardas: Gintas
Amzius: 36
5-asis zmogus
Vardas: Inga
Amzius: 23

Ivesti duomenys

+----------------------+--------+
| Vardas               | Amzius |
+----------------------+--------+
| Greta                | 19     |
| Gintare              | 20     |
| Povilas              | 21     |
| Gintas               | 36     |
| Inga                 | 23     |
+----------------------+--------+

# Pavyzdys 9

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Masyvo sukūrimas
    int skaiciai[10];
    int kiek = 0;

    // Kiek žmogus nori įvesti skaičių?
    cout << "Kiek skaiciu norite ivesti? ";
    cin >> kiek;

    // Patikrinimas ar neviršija sukurto masyvo dydžio
    if (kiek >= 10)
    {
        cout << "Negalite ivesti tiek skaiciu, rinkite iki 10" << endl;
    }
    else
    {
        // Skaičių įvedimas
        cout << "Iveskite visus norimus skaicius: ";

        for (int i = 0; i < kiek; i++)
        {
            cin >> skaiciai[i];
        }

        // Skaičių išvedimas
        cout << "Visi ivesti skaiciai: ";

        for (int i = 0; i < kiek; i++)
        {
            cout << skaiciai[i] << " ";
        }
    }

    return 0;
}

Rezultatas 1:

Kiek skaiciu norite ivesti? 5
Iveskite visus norimus skaicius: 8 9 7 5 3
Visi ivesti skaiciai: 8 9 7 5 3

Rezultatas 2:

Kiek skaiciu norite ivesti? 8
Iveskite visus norimus skaicius: 2 5 4 8 4 3
1 4
Visi ivesti skaiciai: 2 5 4 8 4 3 1 4

# Pavyzdys 10

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas tuščias skaičių masyvas
    int skaiciai[5];
    int skaiciu_kiekis = 5;

    // Bandoma gauti reikšmės iš neužpildyto masyvo
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        cout << "[" << skaiciai[i] << "]";
    }

	return 0;
}

Rezultatai:

[-858993460][-858993460][-858993460][-858993460][-858993460]

# Pavyzdys 11

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas tuščias skaičių masyvas
    int skaiciai[5];
    int skaiciu_kiekis = 5;

    // Kiekvienas masyvo elementas užpildomas su 'default' reikšme
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        skaiciai[i] = 0;
    }

    // Išvedamas sutvarkytas masyvas
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        cout << "[" << skaiciai[i] << "]";
    }

	return 0;
}

Rezultatai:

[0][0][0][0][0]

# Pavyzdys 12

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas tuščias skaičių masyvas
    int skaiciai[5] = {0};
    int skaiciu_kiekis = 5;

    // Išvedamas skaičių masyvas
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        cout << "[" << skaiciai[i] << "]";
    }

	return 0;
}

Rezultatai:

[0][0][0][0][0]

# Pavyzdys 13

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas tuščias skaičių masyvas
    int skaiciai[10];
    int skaiciu_kiekis = 0;

    // Vartotojas įveda kiek skaičių nori suvesti
    cout << "Kiek skaiciu norite suvesti? ";
    cin >> skaiciu_kiekis;

    // Apibūdinami apribojimai skaičių įvedime
    cout << "Iveskite " << skaiciu_kiekis << " skaiciu, kurie butu tarp reziu [1-10]\n";

    // Skaičių įvedimas
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        // Pasakoma kuris skaičius yra įvedinėjamas
        cout << "Iveskite " << i + 1 << "-aji skaiciu: ";
        int skaicius;

        do
        {
            // Įvedamas skaičius
            cin >> skaicius;

            // Jeigu skaičius tinka - įkeliama į masyvą
            if (skaicius >= 1 && skaicius <= 10)
            {
                skaiciai[i] = skaicius;
            }
            else
            {
                // Jeigu skaičius netinka - išvedamas klaidos pranešimas
                cout << "Blogas ivedimas, bandykite is naujo\n";
            }
        } while (skaicius < 1 || skaicius > 10); // kartojama kol įvestas skaičius tinka
    }

    // Skaičių išvedimas
    cout << "Ivesti skaiciai: ";

    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        cout << "[" << skaiciai[i] << "]";
    }

    return 0;
}

Rezultatas 1:

Kiek skaiciu norite suvesti? 3
Iveskite 3 skaiciu, kurie butu tarp reziu [1-10]
Iveskite 1-aji skaiciu: 1
Iveskite 2-aji skaiciu: 55
Blogas ivedimas, bandykite is naujo
14
Blogas ivedimas, bandykite is naujo
5
Iveskite 3-aji skaiciu: 9
Ivesti skaiciai: [1][5][9]

Rezultatas 2:

Kiek skaiciu norite suvesti? 4
Iveskite 4 skaiciu, kurie butu tarp reziu [1-10]
Iveskite 1-aji skaiciu: 5
Iveskite 2-aji skaiciu: 9
Iveskite 3-aji skaiciu: 787
Blogas ivedimas, bandykite is naujo
455
Blogas ivedimas, bandykite is naujo
3
Iveskite 4-aji skaiciu: 1
Ivesti skaiciai: [5][9][3][1]

# Pavyzdys 14

Kodas:

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string zodis = "dramblys"; // čia tas pats kas char masyvas

	for (int i = 0; i < zodis.length(); i++) // vietoj length() galima ir size()
	{
		cout << zodis[i] << " ";
	}

    return 0;
}

Rezultatai:

d r a m b l y s

# Pavyzdys 15

Kodas:

#include <iostream>
#include <string>
#include <cmath>
using namespace std;

int main()
{
    int kiekis;
    int laipsnis;

    cout << "Iveskite skaiciu kieki: ";
    cin >> kiekis;
    cout << endl;

    int skaiciai[kiekis];
    cout << "Iveskite skaicius: ";
	for (int i = 0; i < kiekis; i++)
	{
		cin >> skaiciai[i];
	}

    cout << endl << "Kiek laipsniu norite pakelti skaicius: ";
    cin >> laipsnis;

    cout << endl << "Jusu ivesti skaiciai pakelti: " << laipsnis << " laipsniu: ";
    for (int i = 0; i < kiekis; i++) 
	{
		cout << pow(skaiciai[i], laipsnis) << " ";  
	}

    return 0;
}

Rezultatai:

Iveskite skaiciu kieki: 3

Iveskite skaicius: 3 6 9

Kiek laipsniu norite pakelti skaicius: 3

Jusu ivesti skaiciai pakelti 3 laipsniu: 27 216 729

# Užduotys

# Užduotis 1

Sukurkite norimo dydžio skaičių masyvą, kuris iškart būtų užpildytas skaičiais.

Šiuos skaičius išveskite tris kartus:

Pirmąjį kartą - išvedant visus skaičius toje pačioje eilutėje, atskiriant kableliu ir tarpu.
Antrąjį kartą - išvedant visus skaičius atskirose eilutėse, prieš kiekvieną skaičių parašant kelintasis tai skaičius, pavyzdžiui, "1-asis skaičius yra ...", tada "2-asis skaičius yra...".
Trečiąjį kartą - išvedant tik kas antrą skaičių iš masyvo, skaičius išvedant toje pačioje eilutėje, atskiriant tarpu.

Taip pat, atlikite šiuos veiksmus:

Išveskite pirmąjį skaičių iš masyvo.
Išveskite antrąjį skaičių iš masyvo.
Išveskite paskutinį skaičių iš masyvo.

# Užduotis 2

Susikurkite vardų masyvą, kuris jau būtų užpildytas vardais.
Išveskite vardus sąrašo pavidalu, išvedant kelintas tai vardas, kad tai vardas ir išvedant patį vardą. Pavyzdžiui:

- 1-as vardas: Tomas.
- 2-as vardas: Greta.
- ...

Papildomai: leiskite vartotojui pakeisti bet kurį vardą, įvedant vardo numerį, o po pakeitimo visas sąrašas turi atsivaizduoti dar kartą.

# Užduotis 3

Susikurkite simbolių (char) masyvą, kuris jau būtų užpildytas su jūsų pasirinktais simboliais.
Išveskite visus simbolius toje pačioje eilutėje, neatskiriant jokiu tarpu ar kitu simboliu. Pavyzdžiui:

*d&s^%d$dj#*

Su šio masyvo simboliais nupieškite kvadratą nenaudojant ciklo. Pavyzdžiui:

*#%*
(  $
^52&

Su šio masyvo simboliais nupieškite laiptus nenaudojant ciklo. Pavyzdžiui:

$
#*
Y(*
&@@)

# Užduotis 4

Susikurkite du skaičių masyvus, kurie iškart būtų užpildyti duomenimis.
Vartotojui leiskite pasirinkti kurį skaičių masyvą (pirmą ar antrą) parodyti ekrane.
Vartotojui pasirinkus, kurį masyvą parodyti, visus jo skaičius išveskite toje pačioje eilutėje, kiekvieną skaičių apskliaudžiant laužtiniais ([ ]) skliaustais.

# Užduotis 5

Sukurkite trijų studentų pažymių masyvus (tris atskirus masyvus) su duomenimis, kuriuose pažymiai gali būti rašomi per kablelį, o pažymių kiekis kiekviename masyve gali būti skirtingas.
Išveskite kiekvieną masyvą atskirose eilutėse, prieš kiekvieną masyvą parašant kas yra išvedama. O taip pat, pažymius rašyti toje pačioje eilutėje ir atskiriant vertikaliu brūkšniu. Pavyzdžiui:

1-o moksleivio pažymiai: 7.4 | 8 | 9.6 | 8 | 6.8
2-o moksleivio pažymiai: 10 | 9.5 | 9.4 | 9.8 | 8.6 | 10 | 9.7
3-o moksleivio pažymiai: 8 | 7 | 6.8

# Užduotis 6

Sukurkite skaičių masyvą, kuriame iš pradžių nebūtų duomenų.
Leiskite vartotojui pasirinkti kiek duomenų jis nori įvesti, bei leiskite jam tuos duomenis įvesti, kiekvienoje įvedimo eilutėje nurodant kelintą skaičių jis įvedinėja. Pavyzdžiui:

1-asis skaičius: ...
2-asis skaičius: ...
...

Galiausiai visus skaičius išveskite gražiai, lentelės pavidalu, kur pirmas stulpelis parodytų kelintas tai skaičius, o antrame stulpelyje būtų skaičius iš masyvo. Pavyzdžiui:

+-----+----------+
| #   | Skaičius |
+-----+----------+
| 1   | 8        |
| 2   | 15       |
| 3   | 32       |
| 4   | 5        |
| 5   | 1        |
+-----+----------+

Po lentele išveskite kiek skaičių šiame masyve yra iš viso. Pavyzdžiui: "Lentelėje yra 5 skaičiai".

# Užduotis 7

Susikurkite vardų ir vardų ilgių masyvus.
Leiskite vartotojui suvesti norimą kiekį vardų.
Paskaičiuokite vardų ilgius ir sudėkite atsakymus į vardų ilgių masyvą.
Išveskite vardus ir jų ilgius sąrašo pavidalu. Pavyzdžiui:

- Vardo "Jonas" ilgis 5 simboliai.
- Vardo "Gintarė" ilgis 7 simboliai.
- ...

# Užduotis 8

Susikurkite skaičių masyvą ir leiskite vartotojui jį užpildyti norimu kiekiu skaičių.
Leiskite vartotojui įvesti norimą laipsnį (skaičių, kuriuo bus pakelti suvesti skaičiai).
Sukurkite naują masyvą į kurį paskaičiuokite ir sudėkite suvestų skaičių kvadratų reikšmes.
Sukurkite naują masyvą į kurį paskaičiuokite ir sudėkite suvestų skaičių, pakeltų nurodytu laipsniu, reikšmes.
Visus atsakymus išveskite atskirose eilutėse. Pavyzdžiui:

Suvesti skaičiai:
2 4 9 3

Šių skaičių kvadratai:
4 16 81 9

Šie skaičiai pakelti 5-u laipsniu:
32 1024 59049 243

Papildomai: visus atsakymus išveskite lentelės pavidalu. Pavyzdžiui:

+----------+-----------+---------------+
| Skaičius | Kvadratas | 5-as laipsnis |
+----------+-----------+---------------+
| 2        | 4         | 32            |
| 4        | 16        | 1024          |
| 9        | 81        | 59049         |
| 3        | 9         | 243           |
+----------+-----------+---------------+

# Užduotis 9

Susikurkite string tipo kintamąjį su norima reikšme.
Išveskite visą žodį, kiekvieną raidę atskirant brūkšniu (-). Pavyzdžiui:

d-r-a-m-b-l-y-s

Išveskite kiekvieną raidę atskirose eilutėse. Pavyzdžiui:

d
r
a
m
b
l
y
s

# Užduotis 10

Susikurkite du skaičių masyvus į kuriuos leiskite vartotojui suvesti po kiek nori skaičių.
Išveskite tik tą masyvą, kuris turi daugiau skaičių.
Nurodykite per kiek skaičių skiriasi skaičių kiekis. Pavyzdžiui: "Išvestas masyvas didesnis per 3 skaičius".

# Užduotis 11 (sudėtingesnė)

Leiskite vartotojui suvesti norimą kiekį skaičių.
Sukurkite naują masyvą, kurį užpildykite tais pačiais skaičiais, tačiau atvirkštine tvarka.
Išveskite naują masyvą.

# Užduotis 12 (sudėtingesnė)

Vartotojui leiskite suvesti norimą kiekį skaičių.
Vienoje eilutėje išveskite visus suvestus skaičius.
Kitoje eilutėje išveskite tik lyginius skaičius iš įvestų.
Dar kitoje eilutėje išveskite tik nelyginius skaičius iš įvestų.

# Užduotis 13 (sudėtingesnė)

Susikurkite masyvą iš 25-ių skaičių.
Išveskite šiuos skaičius 5x5 dydžio lentelėje.

# Vienmačiai masyvai: skaičiavimai (suma, vidurkis, kiekis, ...)

# Pavyzdžiai

# Pavyzdys 1

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas skaičių masyvas ir užpildomas reikšmėmis
    int skaiciai[] = { 7, 8, 5, 6, 9, 5 };
    int skaiciu_kiekis = 6;

    // Išvedami skaičiai iš masyvo
    cout << "Skaiciai: ";

    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        cout << "[" << skaiciai[i] << "]";
    }

    cout << endl;

    // Sukuriamas kintamasis, kur bus saugomas rastos sumos atsakymas
    int suma = 0;

    // Ieškoma skaičių suma
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        suma += skaiciai[i];
    }

    // Išvedamas atsakymas
    cout << "Siu skaiciu suma: " << suma << endl;

    return 0;
}

Rezultatai:

Skaiciai: [7][8][5][6][9][5]
Siu skaiciu suma: 40

# Pavyzdys 2

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas skaičių masyvas ir užpildomas reikšmėmis
    int skaiciai[] = { 8, 9, 6, 5, 4, 7, 8, 2, 3, 5, 6, 4, 1, 2, 5 };
    int skaiciu_kiekis = 15;

    // Išvedami skaičiai iš masyvo
    cout << "Skaiciai: ";

    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        cout << "[" << skaiciai[i] << "]";
    }

    cout << endl;

    // Sukuriami kintamieji, kur bus saugomi rastų sumų atsakymai
    int lyginiu_suma = 0;
    int nelyginiu_suma = 0;

    // Ieškomos skaičių sumos
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        if (skaiciai[i] % 2 == 0)
        {
            lyginiu_suma += skaiciai[i];
        }
        else
        {
            nelyginiu_suma += skaiciai[i];
        }
    }

    // Išvedami atsakymai
    cout << "Lyginiu skaiciu suma: " << lyginiu_suma << endl;
    cout << "Nelyginiu skaiciu suma: " << nelyginiu_suma << endl;

    return 0;
}

Rezultatai:

Skaiciai: [8][9][6][5][4][7][8][2][3][5][6][4][1][2][5]
Lyginiu skaiciu suma: 40
Nelyginiu skaiciu suma: 35

# Pavyzdys 3

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas skaičių masyvas ir užpildomas reikšmėmis
    int skaiciai[] = { 8, 5, 3, 6, 5, 4 };
    int skaiciu_kiekis = 6;

    // Išvedami skaičiai iš masyvo
    cout << "Skaiciai: ";

    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        cout << "[" << skaiciai[i] << "]";
    }

    cout << endl;

    // Sukuriamas kintamasis, kur bus saugomas sumos atsakymas
    int suma = 0;

    // Ieškoma skaičių suma
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        suma += skaiciai[i];
    }

    // Skaičiuojamas vidurkis
    double vidurkis = (double)suma / skaiciu_kiekis;

    // Išvedami atsakymai
    cout << "Suma: " << suma << endl;
    cout << "Vidurkis: " << vidurkis << endl;

    return 0;
}

Rezultatai:

Skaiciai: [8][5][3][6][5][4]
Suma: 31
Vidurkis: 5.16667

# Pavyzdys 4

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas skaičių masyvas ir užpildomas reikšmėmis
    int skaiciai[] = { 8, 5, 3, 6, 5, 4 };
    int skaiciu_kiekis = 6;

    // Išvedami skaičiai iš masyvo
    cout << "Skaiciai: ";

    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        cout << "[" << skaiciai[i] << "]";
    }
    cout << endl;

    // Sukuriamas kintamasis, kur bus saugomas sumos atsakymas
    int suma = 0;

    // Ieškoma skaičių suma
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        suma += skaiciai[i];
    }

    // Skaičiuojamas vidurkis
    double vidurkis = (double)suma / skaiciu_kiekis;

    // Sukuriamas kintamasis papildomam skaičiavimui
    int didesniu_nei_vidurkis_suma = 0;

    // Ieškoma didesnių nei vidurkis skaičių suma
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        if (skaiciai[i] > vidurkis)
        {
            didesniu_nei_vidurkis_suma += skaiciai[i];
        }
    }

    // Išvedami atsakymai
    cout << "Skaiciu suma: " << suma << endl;
    cout << "Skaicius vidurkis: " << vidurkis << endl;
    cout << "Didesniu nei vidurkis suma: " << didesniu_nei_vidurkis_suma << endl;

    return 0;
}

Rezultatai:

Skaiciai: [8][5][3][6][5][4]
Skaiciu suma: 31
Skaicius vidurkis: 5.16667
Didesniu nei vidurkis suma: 14

# Pavyzdys 5

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas tuščias pažymių masyvas
    int pazymiai[10];
    int pazymiu_kiekis = 0;

    // Klausiama žmogaus kiek pažymių nori suvesti
    cout << "Kiek pazymiu norite suvesti? ";
    cin >> pazymiu_kiekis;

    // Suvedami visi pažymiai į masyvą
    for (int i = 0; i < pazymiu_kiekis; i++)
    {
        cout << i + 1 << "-asis pazymys: ";
        cin >> pazymiai[i];
    }

    cout << endl;

    // Ieškoma suma

    int suma = 0;

    for (int i = 0; i < pazymiu_kiekis; i++)
    {
        suma += pazymiai[i];
    }

    // Ieškomas vidurkis
    double vidurkis = (double)suma / pazymiu_kiekis;

    // Išvedamas atsakymas
    cout << "Ivestu pazymiu vidurkis: " << vidurkis;

    return 0;
}

Rezultatas 1:

Kiek pazymiu norite suvesti? 7
1-asis pazymys: 5
2-asis pazymys: 6
3-asis pazymys: 3
4-asis pazymys: 2
5-asis pazymys: 1
6-asis pazymys: 5
7-asis pazymys: 3

Ivestu pazymiu vidurkis: 3.57143

Rezultatas 2:

Kiek pazymiu norite suvesti? 3
1-asis pazymys: 8
2-asis pazymys: 9
3-asis pazymys: 8

Ivestu pazymiu vidurkis: 8.33333

# Pavyzdys 6

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas skaičių masyvas ir užpildomas reikšmėmis
    int skaiciai[] = { 7, 4, 5, 9, 5, 2, 8, 1 };
    int skaiciu_kiekis = 8;

    // Išvedami skaičiai esantys masyve
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        cout << "[" << skaiciai[i] << "]";
    }
    cout << endl;

    // Sukuriami kintamieji skaičiavimams
    int lyginiu_kiekis = 0, lyginiu_suma = 0;
    double lyginiu_vidurkis = 0;

    // Einama per visus skaičius
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        // Žiūrima ar skaičius lyginis
        if (skaiciai[i] % 2 == 0)
        {
            // Lyginių kiekis didinamas vienu
            lyginiu_kiekis++;

            // Lyginių suma padidinama nauju skaičiumi
            lyginiu_suma += skaiciai[i];
        }
    }

    // Skaičiuojamas lyginių vidurkis
    lyginiu_vidurkis = (double)lyginiu_suma / lyginiu_kiekis;

    // Išvedami atsakymai
    cout << "Lyginiu skaiciu kiekis: " << lyginiu_kiekis << endl;
    cout << "Lyginiu skaiciu suma: " << lyginiu_suma << endl;
    cout << "Lyginiu skaiciu vidurkis: " << lyginiu_vidurkis << endl;

    return 0;
}

Rezultatai:

[7][4][5][9][5][2][8][1]
Lyginiu skaiciu kiekis: 3
Lyginiu skaiciu suma: 14
Lyginiu skaiciu vidurkis: 4.66667

# Užduotys

# Užduotis 1

Susikurkite skaičių masyvą, kurį reikšmėmis galite užpildyti tiesiai programoje arba leisti suvesti vartotojui.
Raskite šių skaičių sumą, vidurkį.
Raskite skaičių, didesnių už vidurkį, kiekį.
Išveskite turimus skaičius, bei visus gautus atsakymus.

# Užduotis 2

Susikurkite skaičių masyvą, kurį reikšmėmis galite užpildyti tiesiai programoje arba leisti suvesti vartotojui.
Iš šių skaičių raskite sumą tų skaičių, kurie yra lyginiai ir yra didesnių nei bendras turimų skaičių vidurkis.
Išveskite visus pradinius skaičius ir atsakymus.

# Užduotis 3

Vartotojui leiskite suvesti dviejų studentų pažymius (į du skirtingus masyvus).
Paskaičiuokite kiekvieno studento pažymių vidurkius.
Išveskite kiekvieno studento pažymius ir gautus vidurkius.
Nurodykite, kurio studento vidurkis yra didesnis, bei per kokią dalį vidurkis skiriasi.

# Užduotis 4

Turite viso mėnesio, kiekvienos dienos temperatūras.
Raskite kiek dienų siekė 20 laipsnių ar buvo šiltesnės nei 20 laispsnių ir koks tokių dienų vidurkis.
Raskite kiek dienų buvo mažiau nei 20 laipsnių ir koks tokių dienų vidurkis.
Raskite koks skirtumas tarp šiltų ir vėsesnių dienų vidurkių.
Kurių dienų (šiltesnių ar vėsesnių) buvo daugiau?
Išveskite pradinius duomenis, bei gautus atsakymus.

# Užduotis 5

Studentas rašo baigiamąjį darbą ir jūs žinote po kiek puslapių kiekvieną dieną iki šiol jam pavyko parašyti.
Jūs taip pat žinote, kad galutinį dokumentą studentas turi pateikti už x dienų, bei žinote kiek minimaliai puslapių reikia būti parašius.
Pamėginkite paskaičiuoti ar studentas spės parašyti baigiamąjį darbą, jei sugebės išlaikyti tokį patį darbo tempą.
Išveskite gautus atsakymus.

# Užduotis 6

Krepšininkas treniruojasi varžyboms. Jūs turite informaciją apie tai kiek taškų jis įmetė per kiekvieną treniruotę.
Paskaičiuokite kiek vidutiniškai taškų jis įmeta per kiekvieną treniruotę.
Žinote koks yra bendras komandos vidurkis taškų vidurkis kiekvienoje treniruotėje.
Palyginkite šio krepšininko treniruočių taškų vidurkį su komandos vidurkiu. Kaip jam sekasi?
Išveskite turimus pradinius duomenis, bei gautus atsakymus.

# Užduotis 7

Turite parduotuvės prekių informaciją (prekių pavadinimai, jų kiekiai, vieno vieneto kaina).
Raskite kiek parduotuvė uždirbtų jei būtų išpirktos visos turimos prekės.
Raskite kokia vidutinė vienos prekės kaina.
Visą pradinę informaciją išveskite lentelės pavidalu ir tuomet pateikite visus gautus skaičiavimus.

# Užduotis 8

Jums yra žinoma kiek duonos kepalų kiekvieną dieną kepykla iškepdavo per praėjusias dvi savaites.
Jums yra žinoma, kiek artimiausios dviems savaitėms kepykla turi užsakymų.
Pamėginkite prognozuoti ar kepykla spės patenkinti visus būsimus užsakymus (galbūt jums galėtų padėti vidurkio paskaičiavimas ir palyginimas).
Išveskite pradinius duomenis ir gautus skaičiavimus.

# Vienmačiai masyvai: atrinkimas, filtravimas

# Pavyzdžiai

# Pavyzdys 1

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas skaičių masyvas su skaičiais
    int skaiciai[] = { 4, 7, 8, 5, 3, 2, 1, 4 };
    int skaiciu_kiekis = 8;

    // Išvedami visi skaičiai
    cout << "Visi skaiciai" << endl;

    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    // Atrenkami ir išvedami visi lyginiai skaičiai iš masyvo
    cout << endl << "Lyginiai skaiciai is masyvo" << endl;

    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        if (skaiciai[i] % 2 == 0)
        {
            cout << skaiciai[i] << " ";
        }
    }

    cout << endl;

    return 0;
}

Rezultatai:

Visi skaiciai
4 7 8 5 3 2 1 4
Lyginiai skaiciai is masyvo
4 8 2 4

# Pavyzdys 2

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas skaičių masyvas su skaičiais
    int skaiciai[] = { 4, 7, 8, 5, 3, 2, 1, 4 };
    int skaiciu_kiekis = 8;

    // Išvedami visi skaičiai
    cout << "Visi skaiciai" << endl;

    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    cout << endl;

    // Sukuriamas masyvas ir naujas kiekio kintamasis atrinktiems skaičiams
    int atrinkti_skaiciai[10];
    int atrinktu_skaiciu_kiekis = 0;
    
    // Atrenkami skaičiai
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        // Ar skaičius lyginis?
        if (skaiciai[i] % 2 == 0)
        {
            // Įrašomas skaičius į naują masyvą
            atrinkti_skaiciai[atrinktu_skaiciu_kiekis] = skaiciai[i];

            // Naujo masyvo kiekis padidinamas vienu
            atrinktu_skaiciu_kiekis++;
        }
    }

    // Išvedami visi atrinkti skaičiai iš naujo masyvo
    cout << "Atrinkti skaiciai" << endl;

    for (int i = 0; i < atrinktu_skaiciu_kiekis; i++)
    {
        cout << atrinkti_skaiciai[i] << " ";
    }

    cout << endl;

    return 0;
}

Rezultatai:

Visi skaiciai
4 7 8 5 3 2 1 4
Atrinkti skaiciai
4 8 2 4

# Pavyzdys 3

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas skaičių masyvas su skaičiais
    int skaiciai[] = { 4, 7, 8, 5, 3, 2, 1, 4 };
    int skaiciu_kiekis = 8;

    // Išvedami visi skaičiai ir ieškoma skaičių suma

    cout << "Visi skaiciai" << endl;

    int skaiciu_suma = 0;

    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        // Skaičius išvedamas į ekraną
        cout << skaiciai[i] << " ";

        // Skaičius pridedamas prie bendros sumos
        skaiciu_suma += skaiciai[i];
    }

    cout << endl;

    // Ieškomas ir išvedamas skaičių vidurkis
    double skaiciu_vidurkis = (double)skaiciu_suma / skaiciu_kiekis;
    cout << "Skaiciu vidurkis" << endl << skaiciu_vidurkis << endl;

    // Sukuriamas masyvas ir naujas kiekio kintamasis atrinktiems skaičiams
    int atrinkti_skaiciai[10];
    int atrinktu_skaiciu_kiekis = 0;
    
    // Atrenkami skaičiai
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        // Ar skaičius didesnis už vidurkį?
        if (skaiciai[i] > skaiciu_vidurkis)
        {
            // Įrašomas skaičius į naują masyvą
            atrinkti_skaiciai[atrinktu_skaiciu_kiekis] = skaiciai[i];

            // Naujo masyvo kiekis padidinamas vienu
            atrinktu_skaiciu_kiekis++;
        }
    }

    // Išvedami visi atrinkti skaičiai iš naujo masyvo
    cout << "Atrinkti skaiciai, kurie didesni uz vidurki" << endl;

    for (int i = 0; i < atrinktu_skaiciu_kiekis; i++)
    {
        cout << atrinkti_skaiciai[i] << " ";
    }

    cout << endl;

    return 0;
}

Rezultatai:

Visi skaiciai
4 7 8 5 3 2 1 4
Skaiciu vidurkis
4.25
Atrinkti skaiciai, kurie didesni uz vidurki
7 8 5

# Pavyzdys 4

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas temperatūrų masyvas su duomenimis
    double temperaturos[] = { 25.5, 24.3, -17.5, 9.4, -1.05 };
    int temperaturu_kiekis = 5;

    // Sukuriamas tuščias teigimaų temperatūrų masyvas
    double teigiamos_temperaturos[10];
    int teigiamu_temp_kieks = 0;

    // Sukuriamas tuščias neigiamų temperatūrų masyvas
    double neigiamos_temperaturos[10];
    int neigiamu_temp_kiekis = 0;

    // Atrenkamos temperatūros
    for (int i = 0; i < temperaturu_kiekis; i++)
    {
        // Ar temperatūra teigiama?
        if (temperaturos[i] > 0)
        {
            // Įrašyti į teigiamų temperatūrų masyvą ir kiekį padidinti vienu
            teigiamos_temperaturos[teigiamu_temp_kieks++] = temperaturos[i];
        }
        else
        {
            // Įrašyti į neigiamų temperatūrų masyvą ir kiekį padidinti vienu
            neigiamos_temperaturos[neigiamu_temp_kiekis++] = temperaturos[i];
        }
    }

    // Išvesti pradines temperatūras
    cout << "Temperaturos:\n";

    for (int i = 0; i < temperaturu_kiekis; i++)
    {
        cout << "[ " << temperaturos[i] << " ]";
    }

    // Išvesti atrinktas teigiamas temperatūras
    cout << "\nTeigiamos temperaturos:\n";

    for (int i = 0; i < teigiamu_temp_kieks; i++)
    {
        cout << "[ " << teigiamos_temperaturos[i] << " ]";
    }

    // Išvesti atrinktas neigimas temperatūras
    cout << "\nNeigiamos temperaturos:\n";

    for (int i = 0; i < neigiamu_temp_kiekis; i++)
    {
        cout << "[ " << neigiamos_temperaturos[i] << " ]";
    }

    return 0;
}

Rezultatai:

Temperaturos:
[ 25.5 ][ 24.3 ][ -17.5 ][ 9.4 ][ -1.05 ]
Teigiamos temperaturos:
[ 25.5 ][ 24.3 ][ 9.4 ]
Neigiamos temperaturos:
[ -17.5 ][ -1.05 ]

# Pavyzdys 5

Kodas:

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;

int main()
{
    // Sukuriami masyvai vardams ir amžams saugoti
    string vardai[10];
    int amziai[10];
    int kiek_zmoniu = 0;

    // Užklausiama kiek žmonių bus įvedinėjama
    cout << "Kiek zmoniu norite ivesti? ";
    cin >> kiek_zmoniu;
    cout << endl;

    // Vyksta žmonių duomenų įvedimas į masyvus
    for (int i = 0; i < kiek_zmoniu; i++)
    {
        cout << i + 1 << "-asis zmogus\n";
        cout << "Vardas: ";
        cin >> vardai[i];
        cout << "Amzius: ";
        cin >> amziai[i];
        cout << endl;
    }

    // Klausiama atrinkimo pagal amžių riba
    cout << "Amziaus riba, pagal kuria norite atrinkti (bus atrinkti visi vyresni): ";
    int vyresni_nei = 0;
    cin >> vyresni_nei;

    // Sukuriami nauji masyvai, atrinktiems duomenims saugoti
    string atrinktu_vardai[10];
    int atrinktu_amziai[10];
    int atrinktu_kiekis = 0;

    // Einama per pradinius duomenis
    for (int i = 0; i < kiek_zmoniu; i++)
    {
        // Tikrinama ar amžius didesnis arba lygus nurodytui
        if (amziai[i] >= vyresni_nei)
        {
            // Įrašomas atrinktas vardas į naują masyvą
            atrinktu_vardai[atrinktu_kiekis] = vardai[i];

            // Įrašomas atrinktas amžius į naują masyvą
            atrinktu_amziai[atrinktu_kiekis] = amziai[i];

            // Padidinamas atrinktų duomenų kiekis
            atrinktu_kiekis++;
        }
    }

    // Atrinkti duomenys išvedami lentelės pavidale

    cout << "Atrinkti zmones\n\n";

    cout << "+----------------+--------+\n";
    cout << "| Vardas         | Amzius |\n";
    cout << "+----------------+--------+\n";

    for (int i = 0; i < atrinktu_kiekis; i++)
    {
        cout << "| " << setw(14) << left << atrinktu_vardai[i]
            << " | " << setw(6) << atrinktu_amziai[i] << " |\n";
    }

    cout << "+----------------+--------+\n";

    return 0;
}

Rezultatas 1:

Kiek zmoniu norite ivesti? 4

1-asis zmogus
Vardas: Tomas
Amzius: 18

2-asis zmogus
Vardas: Giedrius
Amzius: 23

3-asis zmogus
Vardas: Inga
Amzius: 17

4-asis zmogus
Vardas: Povilas
Amzius: 16

Amziaus riba, pagal kuria norite atrinkti (bus atrinkti visi vyresni): 18
Atrinkti zmones

+----------------+--------+
| Vardas         | Amzius |
+----------------+--------+
| Tomas          | 18     |
| Giedrius       | 23     |
+----------------+--------+

Rezultatas 2:

Kiek zmoniu norite ivesti? 3

1-asis zmogus
Vardas: Petras
Amzius: 55

2-asis zmogus
Vardas: Tomas
Amzius: 15

3-asis zmogus
Vardas: Gintare
Amzius: 24

Amziaus riba, pagal kuria norite atrinkti (bus atrinkti visi vyresni): 19
Atrinkti zmones

+----------------+--------+
| Vardas         | Amzius |
+----------------+--------+
| Petras         | 55     |
| Gintare        | 24     |
+----------------+--------+

# Užduotys

# Užduotis 1

Susikurkite skaičių masyvą.
Išveskite šiuos skaičius.
Išveskite visus lyginius skaičius iš šio masyvo.
Išveskite visus nelyginius skaičius iš šio masyvo.

Pavyzdžiui:

Skaičiai: 5 8 7 6 5 4 7
Lyginiai: 8 6 4
Nelygiai: 5 7 5 7

Raskite lyginių skaičių sumą.
Raskite nelyginių skaičių sumą.
Raskite lyginių ar nelyginių skaičių suma yra didesnė ir koks skirtumas tarp jų.

# Užduotis 2

Susikurkite skaičių masyvą. Raskite skaičių vidurkį.
Atrinkite į kitą masyvą skaičius, kurie yra didesni už vidurkį.
Išveskite pradinius ir atrinktus duomenis.

# Užduotis 3

Leiskite vartotojui suvesti norimą kiekį vardų.
Leiskite vartotojui pasirinkti raidę, pagal kurią vyks vardų atrinkimas.
Atrinkite vardus, kurie prasideda pasirinkta raide. Norint pasirinkti tik pirmąją raidę, galima naudoti vardai[i][0] arba vardai[i].at(0). Norint transformuoti konkrečią raidę į mažąją, galima naudoti char(tolower('T')).
Atrinkite vardus, kurie turi nurodytą raidę, bet kurioje vardo vietoje.
Išveskite suvestus duomenis, bei atrinktus pagal kažkurį kriterijų.

# Užduotis 4

Susikurkite string tipo kintamąjį, į kurį vartotojas gali įvesti bet kokį norimą žodį.
Iš string kintamojo atrinkite visas balses į naują char masyvą. Balsės: {a, e, i, o, u}.
Raskite rastų balsių kiekį.
Papildomai: kurių balsių žodyje atsikartojo daugiausiai?

# Užduotis 5

Turite informaciją apie paskutinius užsakymus parduotuvėje (užsakymų sumos).
Išveskite visus šiuos duomenis.
Leiskite vartotojui pasirinkti užsakymo sumą nuo kurios atfiltruoti užsakymus.
Atrinkite užsakymus, kurie didesni nei nurodyta suma.
Atvaizduokite atrinktus duomenis.

# Užduotis 6

Turite informaciją apie parduotuvėje turimas prekes (prekių pavadinimai, kiekiai, kainos).
Išveskite pradinius duomenis lentelės pavidale.
Atrinkite prekes, kurių yra turima daugiau nei vartotojo pasirinktas kiekis.
Išveskite atrinktas pagal kiekį prekes lentelėje.
Atrinkite prekes, kurių kaina patenka tarp vartotojo nurodytų rėžių.
Išveskite atrinktas pagal kainą prekes lentelėje.

# Užduotis 7

Turite informaciją apie komandos varžybas (pelnyti taškai ir laimėta ar ne).
Atrinkite visas varžybas, kuriose buvo laimėta.
Atrinkite visas varžybas, kuriose buvo pralaimėta.
Raskite laimėtų ir pralaimėtų varžybų taškų vidurkius. Koks skirtumas tarp šių taškų?
Išveskite pradinius ir atrinktus duomenis.

# Užduotis 8

Leiskite vartotojui įvesti norimą kiekį skaičių.
Susikurkite kitą skaičių masyvą, kurio reikšmes būtų lygios pradinio skaičių masyvo reikšmių kvadratams. Pavyzdžiui, jei turimas masyvas array = {1, 2, 3}, turi būti sukurtas kitas masyvas su reikšmėmis pow_array = {1, 4, 9}.
Iš naujo masyvo atrinkite visus skaičius, kurie dalinasi iš 3.
Išveskite pradinius skaičius, pakeistus skaičius, bei atrinktus skaičius.

# Užduotis 9

Turite informaciją apie vairuotojo kiekvieną dieną nuvažiuotus kilometrus.
Į naują masyvą atrinkite labai ilgas keliones (ilgesnes nei 100 km).
Į naują masyvą atrinkite labai trumpas keliones (trumpesnes nei 30 km).
Raskite trumpų ir ilgų kelionių sumas ir vidurkius.
Raskite koks skirtumas tarp trumpų ir ilgų kelionių vidurkių.
Išveskite pradinius duomenis, atrinktus duomenis ir kitus rastus atsakymus.

# Užduotis 10

Susikurkite žodžių masyvą.
Raskite kiekvieno žodžio balsių kiekius ir sudėkite į atskirą skaičių masyvą.
Atrinkite visus žodžius, kurie turi lyginį kiekį balsių.
Išveskite pradinius ir atrinktus duomenis.

# Užduotis 11

Studentas rašo baigiamąjį darbą. Turite informaciją apie tai kiek puslapių jis parašė kiekvieną dieną.
Raskite kiek vidutiniškai puslapių per dieną parašo studentas.
Atrinkite tuos kartus kai studentas parašė daugiau puslapių nei vidutiniškai.
Išveskite pradinius ir atrinktus duomenis.

# Užduotis 12

Turite penkių studentų pažymius (atskiruose masyvuose).
Į naują masyvą atrinkite visus visų studentų pažymius, kurie yra lygūs arba didesni nei 8.
Raskite atrinktų pažymių vidurkį.
Raskite kokią procentinę dalį iš visų pažymių sudaro šie atrinkti geri pažymiai. Pavyzdžiui, jei pirmas studentas turėjo pažymius = {7, 8, 9}, antras = {9, 5, 3}, atrinkti bus = {8, 9, 9}, šių atrinktų pažymių yra 3, o iš viso yra 6 pažymiai, todėl gerų pažymių yra 50 % nuo visų pažymių.
Išveskite visų studentų pažymius, atrinktus gerus pažymius, bei visus rastus skaičiavimus.

# Vienmačiai masyvai: paieška

# Pavyzdžiai

# Pavyzdys 1

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas skaičių masyvas su reikšmėmis
    int skaiciai[] = { 4, 7, 8, 6, 5, 2, 3 };
    int skaiciu_kiekis = 7;

    // Išvedami skaičiai iš masyvo
    cout << "Skaiciai\n";

    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    // Sukuriamas kintamasis didžiausiam skaičiui saugoti
    int didziausias_skaicius = skaiciai[0];

    // Einama per skaičius ir ieškomas didesnis skaičius
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        // Žiūrima ar skaičius didesnis už didžiausią
        if (skaiciai[i] > didziausias_skaicius)
        {
            // Atnaujinama didžiausio skaičiaus reikšmė
            didziausias_skaicius = skaiciai[i];
        }
    }

    // Išvedamas atsakymas
    cout << "\nDidziausias rastas skaicius\n" << didziausias_skaicius;

    return 0;
}

Rezultatai:

Skaiciai
4 7 8 6 5 2 3
Didziausias rastas skaicius
8

# Pavyzdys 2

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas skaičių masyvas su reikšmėmis
    int skaiciai[] = { 4, 7, 8, 6, 5, 2, 3 };
    int skaiciu_kiekis = 7;

    // Išvedami skaičiai iš masyvo
    cout << "Skaiciai\n";

    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    // Sukuriamas kintamasis mažiausiam skaičiui saugoti
    int maziausias_skaicius = skaiciai[0];

    // Einama per skaičius ir ieškomas mažesnis skaičius
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        // Žiūrima ar skaičius mažesnis už mažiausią
        if (skaiciai[i] < maziausias_skaicius)
        {
            // Atnaujinama mažiausio skaičiaus reikšmė
            maziausias_skaicius = skaiciai[i];
        }
    }

    // Išvedamas atsakymas
    cout << "\nMaziausias rastas skaicius\n" << maziausias_skaicius;

    return 0;
}

Rezultatai:

Skaiciai
4 7 8 6 5 2 3
Maziausias rastas skaicius
2

# Pavyzdys 3

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas skaičių masyvas su reikšmėmis
    int skaiciai[] = { 4, 7, 8, 6, 5, 2, 3 };
    int skaiciu_kiekis = 7;

    // Išvedami skaičiai iš masyvo
    cout << "Skaiciai\n";

    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    // Sukuriamas kintamasis didžiausiam skaičiui saugoti
    int didziausias_skaicius = skaiciai[0];
    int didziausio_indeksas = 0;

    // Einama per skaičius ir ieškomas didesnis skaičius
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        // Žiūrima ar skaičius didesnis už didžiausią
        if (skaiciai[i] > didziausias_skaicius)
        {
            // Atnaujinama didžiausio skaičiaus reikšmė
            didziausias_skaicius = skaiciai[i];

            // Įsimenamas didžiausios skaičiaus indeksas
            didziausio_indeksas = i;
        }
    }

    // Išvedami atsakymai
    cout << "\nDidziausias rastas skaicius\n" << didziausias_skaicius << endl;
    cout << "Didziausio skaiciaus indeksas\n" << didziausio_indeksas << endl;
    cout << "Didziausias skaicius yra kelintas\n" << didziausio_indeksas + 1 << endl;

    return 0;
}

Rezultatai:

Skaiciai
4 7 8 6 5 2 3
Didziausias rastas skaicius
8
Didziausio skaiciaus indeksas
2
Didziausias skaicius yra kelintas
3

# Pavyzdys 4

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas skaičių masyvas su reikšmėmis
    int skaiciai[] = { 3, 7, 5, 6, 5, 2, 3 };
    int skaiciu_kiekis = 7;

    // Išvedami skaičiai iš masyvo

    cout << "Skaiciai: ";

    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    cout << endl;

    // Sukuriami kintamieji ieškomam skaičiui ir jo indeksui išsaugoti
    int pirmas_lyginis = 0;
    int pirmo_lyginio_indeksas = 0;

    // Einama per visus skaičius
    for (int i = 0; i < skaiciu_kiekis; i++)
    {
        // Tikrinama ar skaičius lyginis
        if (skaiciai[i] % 2 == 0)
        {
            // Skaičius įrašomas į kintamąjį
            pirmas_lyginis = skaiciai[i];

            // Skaičiaus indeksas įrašomas į kintamąjį
            pirmo_lyginio_indeksas = i;

            // Sustabdomas ciklas
            break;
        }
    }

    // Išvedami atsakymai
    cout << "Pirmas rastas lyginis skaicius: " << pirmas_lyginis << endl;
    cout << "Sis skaicius yra " << pirmo_lyginio_indeksas + 1 << " pozicijoje";

    return 0;
}

Rezultatai:

Skaiciai: 3 7 5 6 5 2 3
Pirmas rastas lyginis skaicius: 6
Sis skaicius yra 4 pozicijoje

# Pavyzdys 5

Kodas:

#include <iostream>
#include <string>
using namespace std;

int main()
{
    // Sukuriamas tuščias vardų masyvas
    string vardai[10];
    int vardu_kiekis;

    // Vartotojas renkasi kiek vardų norės suvesti
    cout << "Kiek vardu norite ivesti? ";
    cin >> vardu_kiekis;

    // Vardų įvedimas į masyvą
    for (int i = 0; i < vardu_kiekis; i++)
    {
        cout << i + 1 << "-asis vardas: ";
        cin >> vardai[i];
    }

    cout << endl;

    // Sukuriamas kintamasis ilgiausio vardo užsaugojimui
    string ilgiausias_vardas = "";

    // Einama per visus turimus vardus masyve
    for (int i = 0; i < vardu_kiekis; i++)
    {
        // Tikrinama ar vardas yra ilgesnis nei ilgiausias
        if (vardai[i].length() > ilgiausias_vardas.length())
        {
            // Atnaujinama ilgiausio vardo reikšmė
            ilgiausias_vardas = vardai[i];
        }
    }

    // Išvedami atsakymai
    cout << "Ilgiausias rastas vardas: " << ilgiausias_vardas << endl;
    cout << "Ilgiausio rasto vardo ilgis: " << ilgiausias_vardas.length() << endl;

    return 0;
}

Rezultatas 1:

Kiek vardu norite ivesti? 3
1-asis vardas: Tomas
2-asis vardas: Gintare
3-asis vardas: Petras

Ilgiausias rastas vardas: Gintare
Ilgiausio rasto vardo ilgis: 7

Rezultatas 2:

Kiek vardu norite ivesti? 5
1-asis vardas: Giedrius
2-asis vardas: Tomas
3-asis vardas: Inga
4-asis vardas: Povilas
5-asis vardas: Zygimantas

Ilgiausias rastas vardas: Zygimantas
Ilgiausio rasto vardo ilgis: 10

# Pavyzdys 6

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Sukuriamas temperatūrų masyvas
    double temperaturos[] = { 14.5, 25.2, 23.4, 10.9, 11.25 };
    int temperaturu_kiekis = 5;

    // Sukuriami kintamieji mažiausiai ir didžiausiai temperatūroms saugoti
    double maziausia_temperatura = temperaturos[0],
        didziausia_temperatura = temperaturos[0];

    // Einama per visas temperatūras
    for (int i = 0; i < temperaturu_kiekis; i++)
    {
        // Tikrinama ar šita temperatūra didesnė už didžiausią
        if (temperaturos[i] > didziausia_temperatura)
        {
            // Atnaujinama didžiausia temperatūra
            didziausia_temperatura = temperaturos[i];
        }

        // Tikrinama ar šita temperatūra mažesnė už mažiausią
        if (temperaturos[i] < maziausia_temperatura)
        {
            // Atnaujinama mažiausia temperatūra
            maziausia_temperatura = temperaturos[i];
        }
    }

    // Išvedamos visos temperatūros
    cout << "Temperaturos\n";
    for (int i = 0; i < temperaturu_kiekis; i++)
    {
        cout << temperaturos[i] << " ";
    }

    // Išvedami rasti atsakymai
    cout << "\nDidziausia temperatura\n" << didziausia_temperatura << endl;
    cout << "Maziausia temperatura\n" << maziausia_temperatura << endl;
    cout << "Skirtumas tarp siu temperaturu\n"
        << didziausia_temperatura - maziausia_temperatura;

    return 0;
}

Rezultatai:

Temperaturos
14.5 25.2 23.4 10.9 11.25
Didziausia temperatura
25.2
Maziausia temperatura
10.9
Skirtumas tarp siu temperaturu
14.3

# Pavyzdys 7

Kodas:

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;

int main()
{
    // Sukuriami masyvai vardams ir amžiams saugoti
    string vardai[] = { "Jonas", "Gabrielius", "Greta", "Paulius",
                        "Gabrielius", "Julija" };
    int amziai[] = { 56, 23, 25, 21, 30, 34 };
    int kiekis = 6;

    // Išvedami pradiniai duomenys lentelės pavidale

    cout << "+--------------+--------+\n";
    cout << "| Vardas       | Amzius |\n";
    cout << "+--------------+--------+\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << "| " << setw(12) << left << vardai[i] << " | "
            << setw(6) << left << amziai[i] << " |\n";
    }

    cout << "+--------------+--------+\n\n";

    // Sukuriami kintamieji pirmam ilgiausiam vardui ieškoti
    string pirm_ilg_vard = "";
    int pirmo_ilg_vard_ind = 0;

    // Einama per duomenis
    for (int i = 0; i < kiekis; i++)
    {
        // Tikrinama ar vardas ilgesnis nei ilgiausias vardas
        if (vardai[i].length() > pirm_ilg_vard.length())
        {
            // Atnaujinama ilgiausio vardo reikšmė
            pirm_ilg_vard = vardai[i];

            // Atnaujinamas ilgiausio vardo indeksas
            pirmo_ilg_vard_ind = i;
        }
    }

    // Išvedama informacija apie pirmą ilgiausią rastą vardą ir žmogaus vardą
    cout << "Pirmas rastas ilgiausias vardas:\n";
    cout << vardai[pirmo_ilg_vard_ind] << " " << amziai[pirmo_ilg_vard_ind] << "\n\n";

    // Sukuriami kintamieji paskutiniam ilgiausiam vardui ieškoti
    string pask_ilg_vard = "";
    int pask_ilg_vard_ind = 0;

    // Einama per duomenis
    for (int i = 0; i < kiekis; i++)
    {
        // Tikrinama ar vardas ilgesnis nei ilgiausias vardas arba lygus
        if (vardai[i].length() >= pask_ilg_vard.length())
        {
            // Atnaujinama ilgiausio vardo reikšmė
            pask_ilg_vard = vardai[i];

            // Atnaujinamas ilgiausio vardo indeksas
            pask_ilg_vard_ind = i;
        }
    }

    // Išvedama informacija apie paskutinį ilgiausią rastą vardą ir žmogaus vardą
    cout << "Paskutinis rastas ilgiausias vardas:\n";
    cout << vardai[pask_ilg_vard_ind] << " " << amziai[pask_ilg_vard_ind] << endl;

    return 0;
}

Rezultatai:

+--------------+--------+
| Vardas       | Amzius |
+--------------+--------+
| Jonas        | 56     |
| Gabrielius   | 23     |
| Greta        | 25     |
| Paulius      | 21     |
| Gabrielius   | 30     |
| Julija       | 34     |
+--------------+--------+

Pirmas rastas ilgiausias vardas:
Gabrielius 23

Paskutinis rastas ilgiausias vardas:
Gabrielius 30

# Užduotys

# Užduotis 1

Turite informaciją apie taksisto nuvažiuotus kilometrus kiekvieną dieną.
Raskite kiek mažiausiai ir kiek daugiausiai kilometrų per dieną yra nuvažiavęs taksistas.
Raskite ar taksistas kada nors yra nuvažiavęs virš 100 km per dieną.
Raskite ar taksistas kada nors yra nuvažiavęs lygiai 50 km per dieną.
Išveskite pradinę turimą informaciją apie nuvažiuotus kilometrus ir visus rastus atsakymus.

# Užduotis 2

Turite informaciją apie kepyklos iškeptus duonos kepalus kiekvieną dieną (kepalų kiekis per dieną).
Raskite kiek daugiausiai kepalų per dieną yra iškepus kepykla, bei kuri (kelinta) diena tai buvo?
Raskite kiek mažiausiai kepalų per dieną yra iškepus kepykla, bei kuri (kelinta) diena tai buvo?
Koks kepalų skirtumas tarp mažiausiai ir daugiausiai iškeptų duonos kepalų?
Raskite kada pirmą kartą kepykla iškepė daugiau nei 10 duonos kepalų per dieną.
Išveskite pradinius duomenis ir visus rastus atsakymus.

# Užduotis 3

Leiskite vartotojui suvesti norimą kiekį žodžių.
Raskite trumpiausią ir ilgiausią žodžius. Jeigu yra keli vienodo ilgio trumpiausi ar ilgiausi, tai rasti pirmus tokius žodžius.
Raskite iš kiek vidutiniškai raidžių susidaro visi žodžiai. Šį skaičių apvalinkite į norimą pusę.
Raskite pirmą žodį, kuris yra sudarytas iš būtent tokio raidžių kiekio, koks yra rastas (suapvalintas) vidurkis.
Leiskite vartotojui pasirinkti kokio žodžio ieškoti tarp visų turimų žodžių. Raskite kiek kartų kartojasi (kiek kartų galima rasti) vartotojo nurodytas žodis.

# Užduotis 4

Leiskite vartotojui suvesti norimą kiekį pažymių.
Raskite mažiausią pažymį.
Ar rastas mažiausias pažymys yra neigiamas (mažesnis nei 4)?
Išveskite gautus atsakymus.

# Užduotis 5

Turite informaciją apie 3 studentų turimus pažymius (trys skirtingi masyvai).
Raskite kiekvieno studento didžiausią pažymį.
Kuris studentas turi didžiausią iš visų pažymį?
Išveskite pradinius duomenis ir rastus atsakymus.

# Užduotis 6

Jums yra žinoma informacija apie prekes parduotuvėje (prekės pavadinimas, kiekis, vieneto kaina).
Laikykime, kad pavyko išparduoti visas turimas prekes. Iš kurios prekės bus uždirbta daugiausiai (kiekis x kaina)?
O iš kurios bus uždirbta mažiausiai?
Raskite kurios prekės buvo turima daugiausiai kiekio.
Raskite kurios prekės vieneto kaina buvo mažiausia.
Išveskite pradinius duomenis lentelės pavidalu. Išveskite visus gautus atsakymus po lentele.

# Užduotis 7

Turite informaciją apie knygyne esančias knygas (pavadinimas, puslapių skaičius, kaina).
Kokia storiausias knygos kaina?
Koks ploniausios knygos pavadinimas?
Jei sugebėtume per dieną perskaityti po 20 puslapių, per kiek dienų perskaitytume kiekvieną knygą? Šiems atsakymams galima susikurti papildomą masyvą.
Ar yra bent viena knyga, kurią perskaitytume per lygiai 5 dienas? Jei taip, grąžinti pirmą ir paskutinę tokią rastą knygą.
Išveskite turimų knygų informaciją lentelės pavidalu. Išveskite visus gautus atsakymus po lentele. Kiek dienų užtruktume su kiekviena knyga, galima spausdinti toje pačioje lentelėje kaip ir pradiniai knygų duomenys.

# Užduotis 8 (sudėtingesnė)

Sukurkite žodyną, kur vartotojas galėtų įvesti lietuvišką žodį ir jam būtų parodytas angliškas atitikmuo. Tam gali padėti du žodžių masyvai, kur vertimai sutaptų per indeksą. Leiskite vartotojui atlikti tiek vertimų kiek jis nori.

# Užduotis 9 (sudėtingesnė)

Susikurkite string tipo kintamąjį, kuriame saugotumėte norimą tekstą.
Raskite kuri raidė tekste kartojasi daugiausiai kartų.

# Vienmačiai masyvai: rikiavimas

# Algoritmų veikimo vizualizacijos

Šių algoritmų vizualizacijų galima rasti čia (opens new window).

# Rikiavimas Burbuliuko metodu (angl. Bubble sort)

# Pavyzdys 1

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Pradiniai duomenys

    int skaiciai[] = { 47, 125, 23, 35, 49, 254, 354, 15, 28 };
    int kiekis = 9;

    // Skaičių išvedimas

    cout << "Skaiciai:\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    cout << endl;

    // Rikiavimas burbuliuko metodu (bubble sort)

    for (int i = 0; i < kiekis - 1; i++)
    {
        for (int j = 0; j < kiekis - i - 1; j++)
        {
            // Tikrinimas ar reikia apkeisti
            // Ženklas gali būti ir į kitą pusę, jei reikia pakeisti rikiavimo pusę
            if (skaiciai[j] > skaiciai[j + 1])
            {
                // Skaičių apkeitimas vietomis
                // temp turi būti to paties tipo kaip masyvo narių tipas
                int temp = skaiciai[j];
                skaiciai[j] = skaiciai[j + 1];
                skaiciai[j + 1] = temp;
            }
        }
    }

    // Surikiuotų skaičių išvedimas

    cout << "\nSurikiuoti:\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    cout << endl;

    return 0;
}

Rezultatai:

Skaiciai:
47 125 23 35 49 254 354 15 28

Surikiuoti:
15 23 28 35 47 49 125 254 354

# Pavyzdys 2

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Pradiniai duomenys

    int skaiciai[] = { 47, 125, 23, 35, 49, 254, 354, 15, 28 };
    int kiekis = 9;

    // Skaičių išvedimas

    cout << "Skaiciai:\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    cout << endl;

    // Rikiavimas burbuliuko metodu (bubble sort)

    bool rikiuoti = true;

    while (rikiuoti)
    {
        rikiuoti = false;

        for (int i = 0; i < kiekis - 1; i++)
        {
            // Tikrinimas ar reikia apkeisti
            // Ženklas gali būti ir į kitą pusę, jei reikia pakeisti rikiavimo pusę
            if (skaiciai[i] > skaiciai[i + 1])
            {
                // Skaičių apkeitimas vietomis
                swap(skaiciai[i], skaiciai[i + 1]);
                rikiuoti = true;
            }
        }
    }

    // Surikiuotų skaičių išvedimas

    cout << "\nSurikiuoti:\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    cout << endl;

    return 0;
}

Rezultatai:

Skaiciai:
47 125 23 35 49 254 354 15 28

Surikiuoti:
15 23 28 35 47 49 125 254 354

# Pavyzdys 3

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Pradiniai duomenys

    int skaiciai[] = { 47, 125, 23, 35, 49, 254, 354, 15, 28 };
    int kiekis = 9;

    // Skaičių išvedimas

    cout << "Skaiciai:\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    cout << endl;

    // Rikiavimas burbuliuko metodu (bubble sort)

    bool rikiuoti;

    do
    {
        rikiuoti = false;

        for (int i = 0; i < kiekis - 1; i++)
        {
            // Tikrinimas ar reikia apkeisti
            // Ženklas gali būti ir į kitą pusę, jei reikia pakeisti rikiavimo pusę
            if (skaiciai[i] > skaiciai[i + 1])
            {
                // Skaičių apkeitimas vietomis
                swap(skaiciai[i], skaiciai[i + 1]);
                rikiuoti = true;
            }
        }
    } while (rikiuoti);

    // Surikiuotų skaičių išvedimas

    cout << "\nSurikiuoti:\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    cout << endl;

    return 0;
}

Rezultatai:

Skaiciai:
47 125 23 35 49 254 354 15 28

Surikiuoti:
15 23 28 35 47 49 125 254 354

# Pavyzdys 4

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Pradiniai duomenys

    string zodziai[] = { "Jonas", "Petras", "Gintas", "Adomas", "Povilas",
                        "Gabriele", "Gintare", "Julija", "Ona" };
    int kiekis = 8;

    // Žodžių išvedimas

    cout << "Zodziai:\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << zodziai[i] << " ";
    }

    cout << endl;

    // Rikiavimas burbuliuko metodu (bubble sort)

    bool rikiuoti;

    do
    {
        rikiuoti = false;

        for (int i = 0; i < kiekis - 1; i++)
        {
            // Tikrinimas ar reikia apkeisti
            // Ženklas gali būti ir į kitą pusę, jei reikia pakeisti rikiavimo pusę
            if (zodziai[i] > zodziai[i + 1])
            {
                // Žodžių apkeitimas vietomis
                swap(zodziai[i], zodziai[i + 1]);
                rikiuoti = true;
            }
        }
    } while (rikiuoti);

    // Surikiuotų žodžių išvedimas

    cout << "\nSurikiuoti:\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << zodziai[i] << " ";
    }

    cout << endl;

    return 0;
}

Rezultatai:

Zodziai:
Jonas Petras Gintas Adomas Povilas Gabriele Gintare Julija

Surikiuoti:
Adomas Gabriele Gintare Gintas Jonas Julija Petras Povilas

# Pavyzdys 5

Kodas:

#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
    // Pradiniai duomenys

    string vardai[] = { "Jonas", "Petras", "Inga", "Elina" };
    int amziai[] = { 58, 30, 35, 32 };
    int kiekis = 4;

    // Duomenų išvedimas

    cout << "Vardas ir amzius\n\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << setw(10) << left << vardai[i] << " " << amziai[i] << endl;
    }

    cout << endl;

    // Rikiavimas burbuliuko metodu (bubble sort)

    bool rikiuoti;

    do
    {
        rikiuoti = false;

        for (int i = 0; i < kiekis - 1; i++)
        {
            // Tikrinimas ar reikia apkeisti
            // Ženklas gali būti ir į kitą pusę, jei reikia pakeisti rikiavimo pusę
            if (amziai[i] > amziai[i + 1])
            {
                // Apkeitimas vietomis, ne tik amžiai bet ir vardai
                swap(amziai[i], amziai[i + 1]);
                swap(vardai[i], vardai[i + 1]);
                rikiuoti = true;
            }
        }
    } while (rikiuoti);

    // Surikiuotų duomenų išvedimas

    cout << "Surikiuoti\n";
    cout << "Vardas ir amzius\n\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << setw(10) << left << vardai[i] << " " << amziai[i] << endl;
    }

    cout << endl;

    return 0;
}

Rezultatai:

Vardas ir amzius

Jonas      58
Petras     30
Inga       35
Elina      32

Surikiuoti
Vardas ir amzius

Petras     30
Elina      32
Inga       35
Jonas      58

# Pavyzdys 6

Kodas:

#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
    // Pradiniai duomenys

    string vardai[] = { "Jonas", "Petras", "Inga", "Aina" };
    int amziai[] = { 58, 30, 35, 30 };
    int kiekis = 4;

    // Duomenų išvedimas

    cout << "Vardas ir amzius\n\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << setw(10) << left << vardai[i] << " " << amziai[i] << endl;
    }

    cout << endl;

    // Rikiavimas burbuliuko metodu (bubble sort)

    bool rikiuoti;

    do
    {
        rikiuoti = false;

        for (int i = 0; i < kiekis - 1; i++)
        {
            // Pagal amžių didėjimo tvarka,
            // o jei amžius sutampa tai pagal vardą abėcėliškai
            if (amziai[i] > amziai[i + 1] || 
                (amziai[i] == amziai[i + 1] && vardai[i] > vardai[i + 1]))
            {
                // Apkeitimas vietomis, ne tik amžiai bet ir vardai
                swap(amziai[i], amziai[i + 1]);
                swap(vardai[i], vardai[i + 1]);
                rikiuoti = true;
            }
        }
    } while (rikiuoti);

    // Surikiuotų duomenų išvedimas

    cout << "Surikiuoti\n";
    cout << "Vardas ir amzius\n\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << setw(10) << left << vardai[i] << " " << amziai[i] << endl;
    }

    cout << endl;

    return 0;
}

Rezultatai:

Vardas ir amzius

Jonas      58
Petras     30
Inga       35
Aina       30

Surikiuoti
Vardas ir amzius

Aina       30
Petras     30
Inga       35
Jonas      58

# Rikiavimas Įterpimo metodu (angl. Insertion sort)

# Pavyzdys 1

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Pradiniai duomenys

    int skaiciai[] = { 47, 125, 23, 35, 49, 254, 354, 15, 28 };
    int kiekis = 9;

    // Skaičių išvedimas

    cout << "Skaiciai:\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    cout << endl;

    // Rikiavimas įterpimo metodu (insertion sort)

    int j;

    for (int i = 1; i < kiekis; i++)
    {
        j = i;

        // Norint apkeisti rikiavimo pusę, prie skaičių
        // skaiciai[j] < skaiciai[j - 1]
        // galima keisti ženklą į kitą pusę
        while (j > 0 && skaiciai[j] < skaiciai[j - 1])
        {
            // Skaičių apkeitimas
            swap(skaiciai[j], skaiciai[j - 1]);

            j--;
        }
    }

    // Surikiuotų skaičių išvedimas

    cout << "\nSurikiuoti:\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    cout << endl;

    return 0;
}

Rezultatai:

Skaiciai:
47 125 23 35 49 254 354 15 28

Surikiuoti:
15 23 28 35 47 49 125 254 354

# Pavyzdys 2

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Pradiniai duomenys

    int skaiciai[] = { 47, 125, 23, 35, 49, 254, 354, 15, 28 };
    int kiekis = 9;

    // Skaičių išvedimas

    cout << "Skaiciai:\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    cout << endl;

    // Rikiavimas įterpimo metodu (insertion sort)

    int j;

    for (int i = 1; i < kiekis; i++)
    {
        j = i;

        // Norint apkeisti rikiavimo pusę, prie skaičių
        // skaiciai[j] > skaiciai[j - 1]
        // galima keisti ženklą į kitą pusę
        while (j > 0 && skaiciai[j] > skaiciai[j - 1])
        {
            // Skaičių apkeitimas
            int temp = skaiciai[j];
            skaiciai[j] = skaiciai[j - 1];
            skaiciai[j - 1] = temp;

            j--;
        }
    }

    // Surikiuotų skaičių išvedimas

    cout << "\nSurikiuoti:\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    cout << endl;

    return 0;
}

Rezultatai:

Skaiciai:
47 125 23 35 49 254 354 15 28

Surikiuoti:
354 254 125 49 47 35 28 23 15

# Rikiavimas Gnomo metodu (angl. Gnome sort)

# Pavyzdys

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Pradiniai duomenys

    int skaiciai[] = { 47, 125, 23, 35, 49, 254, 354, 15, 28 };
    int kiekis = 9;

    // Skaičių išvedimas

    cout << "Skaiciai:\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    cout << endl;

    // Rikiavimas gnomo metodu (gnome sort)

    for (int i = 0; i < kiekis - 1; i++)
    {
        // Jei reikia rikiavimo į kitą pusę, čia galime pakeisti ženklą
        if (skaiciai[i] > skaiciai[i + 1])
        { 
            // Skaičių apkeitimas
            swap(skaiciai[i], skaiciai[i + 1]);

            if (i > 0)
            {
                i -= 2; // atgal du žingsnius
            }
        }
    }

    // Surikiuotų skaičių išvedimas

    cout << "\nSurikiuoti:\n";

    for (int i = 0; i < kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    cout << endl;

    return 0;
}

Rezultatai:

Skaiciai:
47 125 23 35 49 254 354 15 28

Surikiuoti:
15 23 28 35 47 49 125 254 354

# Užduotys

# Užduotis 1

Leiskite vartotojui suvesti norimą kiekį skaičių.
Surikiuokite skaičius mažėjimo tvarka.
Atvaizduokite tris didžiausius skaičius.

# Užduotis 2

Leiskite vartotojui suvesti norimą kiekį skaičių.
Atrinkite visus lyginius skaičius, bei visus nelyginius skaičius į atskirus masyvus.
Vieną iš atrinktų masyvų surikiuokite didėjimo tvarka, kitą mažėjimo.
Išveskite pradinius duomenis ir atrinktus bei surikiuotus duomenis.

# Užduotis 3

Turite dienų temperatūrų informaciją.
Į vieną masyvą atrinkite aukštas temperatūras (kurios didesnės nei 20 laipsnių), o į kitą žemas (mažesnės nei 10 laipsnių).
Aukštas temperatūras surikiuokite mažėjimo tvarka.
Žemas temperatūras surikiuokite didėjimo tvarka.
Išveskite pradines temperatūras, atrinktas temperatūras ir po top 3 temperatūras, t.y. tris didžiausias ir tris mažiausias.

# Užduotis 4

Sugeneruokite 20 atsitiktinių skaičių, kur kiekvienas skaičius patenka į rėžius [1-100].
Atrinkite skaičius, didesnius nei sugeneruotų skaičių vidurkis.
Surikiuokite atrinktus skaičius didėjimo tvarka.
Išveskite pradinius skaičius, bei atrinkus ir surikiuotus skaičius.

# Užduotis 5

Turite informaciją apie krepšininko pelnytus taškus per įvairas varžybas.
Raskite 5 didžiausius rezultatus (turbūt būtų patogu pirma surikiuoti ir tada gauti kelis reikiamus skaičius).
Raskite šių 5-ių didžiausių rezultatų vidurkį.

# Užduotis 6

Turite informaciją apie prekes (pavadinimas, kiekis, vieneto kaina).
Išveskite šią informaciją lentelės pavidalu.
Surikiuokite prekes pagal kainą, mažėjimo tvarka, o jei kaina sutampa tuomet pagal pavadinimą didėjimo tvarka. Nepamirškite perkelti ir kitų stulpelių. Surikiuotus rezultatus išveskite lentelės pavidalu.

# Vienmačiai masyvai: keitimas (reikšmių įterpimas, šalinimas, ...)

# Pavyzdžiai

# Pavyzdys 1

Skaičių, kurie atitinka tam tikrą sąlygą, keitimas kitais.

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Pradiniai duomenys
    int skaiciai[] = { 8, 9, 8, 5, 3, 5, 4, 2, 3 };
    int kiekis = 9;

    // Ėjimas per pradinius duomenis
    for (int i = 0; i < kiekis; i++)
    {
        // Ar skaičius tenkina sąlygą?
        if (skaiciai[i] % 2 == 0)
        {
            // Skaičiaus keitimas kitu
            skaiciai[i] = 0;
        }
    }

    // Atnaujintų duomenų išvedimas
    for (int i = 0; i < kiekis; i++)
    {
        cout << skaiciai[i] << " ";
    }

    return 0;
}

Rezultatai:

0 9 0 5 3 5 0 0 3

# Pavyzdys 2

Naujo skaičiaus įterpimas nurodytoje vietoje.

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Pradiniai duomenys
    int skaiciai[10] = { 4, 5, 6, 7 };
    int kiek = 4;

    // Pradinių duomenų išvedimas

    cout << "Pradiniai duomenys: ";

    for (int i = 0; i < kiek; i++)
    {
        cout << skaiciai[i] << " ";
    }

    // Turėsim vienu elementu masyve daugiau, todėl padidinam kiekį vienu
    kiek++;

    // Kur įterpti naują elementą ir kokį elementą įterpti
    int kelintoj_vietoj = 2;
    int naujas_skaicius = 30;

    // Visų elementų iki nurodyto pastūmimas vienu atgal
    for (int i = kiek - 1; i > kelintoj_vietoj - 1; i--)
    {
        skaiciai[i + 1] = skaiciai[i];
    }

    // Naujo elemento įterpimas į nurodytą vietą
    skaiciai[kelintoj_vietoj] = naujas_skaicius;

    // Atnaujinto masyvo išvedimas

    cout << "\nSu iterptu skaiciumi: ";

    for (int i = 0; i < kiek; i++)
    {
        cout << skaiciai[i] << " ";
    }

    return 0;
}

Rezultatai:

Pradiniai duomenys: 4 5 6 7
Su iterptu skaiciumi: 4 5 30 6 7

# Pavyzdys 3

Dviejų narių sukeitimas vietomis (šiuo atveju: didžiausio ir mažiausių skaičių).

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Pradiniai duomenys
    int skaiciai[] = { 5, 8, 2, 3, 1, 4 };
    int kiek = 6;

    // Pradinių duomenų išvedimas

    cout << "Pradiniai duomenys: ";

    for (int i = 0; i < kiek; i++)
    {
        cout << skaiciai[i] << " ";
    }

    // Kintamieji ieškomų didž. ir maž. skaičių indeksų saugojimui
    int didziausio_indeksas = 0,
        maziausio_indeksas = 0;

    // Ėjimas per pradinius duomenys
    for (int i = 0; i < kiek; i++)
    {
        // Ar skaičius didesnis už didžiausią?
        if (skaiciai[i] > skaiciai[didziausio_indeksas])
        {
            // Įsimenamas naujas didžiausio skaičiaus indeksas
            didziausio_indeksas = i;
        }

        // Ar skaičius mažesnis už mažiausią?
        if (skaiciai[i] < skaiciai[maziausio_indeksas])
        {
            // Įsimenamas naujas mažiausio skaičiaus indeksas
            maziausio_indeksas = i;
        }
    }

    // Dviejų skaičių apkeitimas vietomis
    int laikinas = skaiciai[didziausio_indeksas];
    skaiciai[didziausio_indeksas] = skaiciai[maziausio_indeksas];
    skaiciai[maziausio_indeksas] = laikinas;

    // arba:
    // swap(skaiciai[didziausio_indeksas], skaiciai[maziausio_indeksas]);

    // Atnaujinto masyvo išvedimas

    cout << "\nApkeisti skaiciai:  ";

    for (int i = 0; i < kiek; i++)
    {
        cout << skaiciai[i] << " ";
    }

    return 0;
}

Rezultatai:

Pradiniai duomenys: 5 8 2 3 1 4
Apkeisti skaiciai:  5 1 2 3 8 4

# Pavyzdys 4

Elemento šalinimas žinant to elemento indeksą.

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Pradiniai duomenys
    int skaiciai[] = { 8, 5, 6, 5, 4, 2 };
    int kiek = 6;

    // Skaičiaus, kuris bus šalinamas, indeksas
    int kuri_salinti_ind = 2;

    // Pradinių duomenų išvedimas

    cout << "Skaiciai:  ";

    for (int i = 0; i < kiek; i++)
    {
        cout << skaiciai[i] << " ";
    }

    // Skaičiai perkeliami vienu į priekį iki šalinamo

    for (int i = kuri_salinti_ind; i < kiek - 1; i++)
    {
        skaiciai[i] = skaiciai[i + 1];
    }

    // Kiekis mažinamas vienu
    kiek--;

    // Atnaujinto masyvo išvedimas

    cout << "\nPasalinta: ";

    for (int i = 0; i < kiek; i++)
    {
        cout << skaiciai[i] << " ";
    }

    return 0;
}

Rezultatai:

Skaiciai:  8 5 6 5 4 2
Pasalinta: 8 5 5 4 2

# Pavyzdys 5

Visų elementų šalinimas, kurie atitinka tam tikrą sąlygą.

Kodas:

#include <iostream>
using namespace std;

int main()
{
    // Pradiniai duomenys
    int skaiciai[] = { 8, 5, 6, 5, 4, 2 };
    int kiek = 6;

    // Kokį skaičių reikės šalinti (įskaitant visus jo atsikartojimus)
    int kuri_salinti = 5;

    // Išvedami pradiniai duomenys

    cout << "Skaiciai:  ";

    for (int i = 0; i < kiek; i++)
    {
        cout << skaiciai[i] << " ";
    }

    // Einama per visus masyvo elementus
    for (int i = 0; i < kiek; i++)
    {
        // Jei skaičius sutampa su norimu pašalinti
        if (skaiciai[i] == kuri_salinti)
        {
            // Šalinimas skaičius iš masyvo
            for (int j = i; j < kiek - 1; j++)
            {
                skaiciai[j] = skaiciai[j + 1];
            }

            // Masyve esančių elementų kiekis mažinamas vienu
            kiek--;

            // Grįžtama pirmame cikle vienu atgal, kad vėl tikrintų toje pačioje
            // vietoje esantį skaičių, nes jeigu negrįš ir iš eilės bus du tokie
            // elementai, kurie atitiktų sąlygą - tai antrasis nebūtų pašalintas
            i--;
        }
    }

    // Išvedamas atnaujintas masyvas

    cout << "\nPasalinta: ";

    for (int i = 0; i < kiek; i++)
    {
        cout << skaiciai[i] << " ";
    }

    return 0;
}

Rezultatai:

Skaiciai:  8 5 6 5 4 2
Pasalinta: 8 6 4 2

# Užduotys

# Užduotis 1

Susikurkite skaičių masyvą.
Kiekvieną nelyginį skaičių pakelkite vienu. Pavyzdžiui, jeigu turite skaiciai = { 7, 4, 5, 6 } tai jis turėtų pasiversti į skaiciai = { 8, 4, 6, 6 }.

# Užduotis 2

Susikurkite masyvą žodžiams saugoti.
Kiekvieną žodį, kuris yra ilgesnis nei 5 simboliai pakeisti į tuščią string. Pavyzdžiui: "dviratis" taps "".

# Užduotis 3

Susikurkite skaičių masyvą.
Raskite mažiausio ir didžiausio skaičių indeksus / pozicijas masyve.
Po mažiausio skaičiaus įterpkite šių dviejų rastų skaičių sumą. Pavyzdžiui, jeigu turite masyvą skaiciai = { 7, 2, 4, 9, 3 }, kuriame didžiausias skaičius yra 9, o mažiausias yra 2, tai masyve už skaičiaus 2 reikia įterpti skaičių 11, nes 2 + 9, dėl ko bus pakeista: skaiciai = { 7, 2, 11, 4, 9, 3 }.

# Užduotis 4

Susikurkite skaičių masyvą.
Iš šio masyvo pašalinkite pirmą lyginį skaičių.
Iš šio masyvo pašalinkite didžiausią skaičių.
Į šį masyvą, į vidurį įterpkite jūsų pasirinktą skaičių.

# Užduotis 5 (sudėtingesnė)

Susikurkite skaičių masyvą
Raskite didžiausią masyvo skaičių.
Didžiausią masyvo skaičių įterpkite po kiekvieno lyginio skaičiaus. Pavyzdžiui, turint skaiciai = { 7, 4, 9, 2, 3 }, didžiausias skaičius yra 9, todėl masyvas bus pakeistas: skaiciai = { 7, 4, 9, 9, 2, 9, 3 }.

# Užduotis 6 (sudėtingesnė)

Susikurkite žodžių masyvą.
Iš šio masyvo pašalinkite visus žodžius, ilgesnius nei 5 simboliai.
Į šį masyvą, pačioje pradžioje, įterpkite bent 2 pasirinktus žodžius.
Papildomai: programą pakeiskite taip, kad šalinami žodžiai taip pat būtų įrašomi į kitą masyvą. Konsolėje išveskite iš pradinio masyvo pašalintus žodžius.