Autorius Tema: c++ darbai su masyvais pavyzdziai  (Skaityta 9695 kartus)

Neprisijungęs Lukas

  • Administratorius
  • Herojus
  • ******
  • Įrašai: 7431
  • Karma: +232/-15
    • Žiūrėti profilį
c++ darbai su masyvais pavyzdziai
« Įrašytas: 2011-12-02 14:23:24 pm »
Sveiki, turejau dabar informatikos dalyka ir buvo uzduotis su masyvais, kadangi jau atsiskaiciau, tai imetu savo koda :) pravers tiems, kurie nori ismokti c++ ;]

prisegu ir uzduoties aprasyma ir keleta konspektu

dar viso kodo kopija pastebin'e, tai sintakse paspalvinta graziai: http://pastebin.com/G7Bs38K0


#include <iostream>
#include <iomanip>
#include <string>
#include <fstream>
#include <cstdlib>

using namespace std;

void meniu();
void baigti();
void spausdinti_matrica(ostream &, double [][100], int, int);
int formuoja_matrica(istream &, double (&)[100][100], int, int);
double matricos_elementu_vidurkis(double [][100], int, int);
int gauti_eilute(double [][100], int, int, char);
int neigiamiausias_stuleplis(double [][100], int, int);
bool ar_egzistuoja_toks_matricos_elementas(int, int, int, int);
int iveda_matrica_is_failo(string, double (&)[100][100], int &, int &);
bool keisti_matricos_elementa_nauja_reiksme(double (&)[100][100], int, int, int, int, double);
void keistiKvadratais(double (&)[100][100], int, int, int);
void rikiuoti_matrica(double (&)[100][100], int, int, int);
double dauginti_teigiamus_elementus(double [][100], int, int);
void sukurti_matrica_pagal_atrinktus_elementus(double (&)[100][100], double (&)[100], int, int);
bool sukeicia_min_max_stulpelius(double (&)[100][100], int, int);
void debug(int, int);
void suformuoti_didziausiu_matricos_elementu_masyva(double (&)[100][100], int, int, double (&)[100]);
void keisti_neigiamus_elementus_kvadratais(double (&)[100][100], int, int, int);

int main() {
// kintamuju aprasai
int x, y, matrica_jau_suformuota = 0;
double didziausi_elementai[100];
string kelias, veiksmas;
string veiksmai[10] = {"3", "4", "5", "6", "7", "8", "9", "10", "11", "13"};
bool veiksmas_egzistuoja = false;
double matrica[100][100];
int maziausiai_elementas_yra_sioje_eiluteje;

cout << "Laboratorinis darbas nr. 3, Lukas Liesis, GM080102\n\n";
cout << "Programa atlieka ivairius veiksmus su matrica pagal vartotojo pasirinkima\n";
cout << "Matrica galima ivesti is failo arba ranka\n";
cout << "Norima ivedimo varianta pasirinkite is meniu ivedus 1 arba 2\n\n";
cout << "Matricos failo formatas yra toks:\n";
cout << "Pirmoje eiluteje nurodyti 2 skaiciai parodo kokio dydzio yra matrica\n";
cout << "Pirmas skaicius nurodo stulpeliu skaiciu, antras  eiluciu\n";
cout << "Kiekvienoje kitoje eiluteje yra surasomi matricos elementu skaicia\n\n";

// meniu spausdinimas
meniu();
// pagrindinis programos ciklas
do {
veiksmas_egzistuoja = false;
cout << "\nIveskite norimo atlikti veiksmo meniu numeri: ";
cin >> veiksmas;
cout << "\n";
if (veiksmas == "0") {
// rodyti meniu
meniu();
} else if (veiksmas == "12") {
// pabaigti programa
baigti();
} else if (veiksmas == "1"){
// ivedimas is failo
cout << "Kelias iki failo: ";
cin >> kelias;
matrica_jau_suformuota = iveda_matrica_is_failo(kelias, matrica, x, y);
if (matrica_jau_suformuota <= 0) {
cout << "Klaida! Blogas kelias iki failo\n";
} else {
cout << "Matrica ivesta. Ji sudaryta is " << x << " stulpeliu ir " << y << " eiluciu.\n";
spausdinti_matrica(cout, matrica, x, y);
}
} else if (veiksmas == "2") {
// rankiniu budu ivesti matrica
cout << "Iveskite matricos stulpeliu skaiciu:\n";
cin >> x;
cout << "Iveskite matricos eiluciu skaiciu:\n";
cin >> y;
if (cin.good()) {
if (ar_egzistuoja_toks_matricos_elementas(100, 100, x, y)) { // ar matricos matmenys nevirsija masyvo
cout << "Iveskite matricos reiksmes: \n";
matrica_jau_suformuota = formuoja_matrica(cin, matrica, x, y);
if (matrica_jau_suformuota == -1 || matrica_jau_suformuota == -2) {
cout << "Klaida! Neteisingi matricos duomenys.\n";
} else {
cout << "Matrica ivesta. Ji sudaryta is " << x << " stulpeliu ir " << y << " eiluciu.\n";
spausdinti_matrica(cout, matrica, x, y); // spausdinam matrica
}
} else {
cout << "Klaida! Toks eiluciu ar stulpeliu kiekis yra negalimas.\n";
cout << "Daugiausia gali buti 100 eiluciu ir 100 stulepliu.\n";
}
}
}  else {
// tikrinam ar egzistuoja nurodytas veiksmas
// prasukam cikla pro visus veiksmus
for(int i = 0; i < sizeof(veiksmai)/sizeof(string); i++) {
if (veiksmas == veiksmai[i]) {
veiksmas_egzistuoja = true;
break;
}
}

if (veiksmas_egzistuoja) {
if (matrica_jau_suformuota == 1) { // tikrinam ar matrica jau suformuota

if (veiksmas == "3") { // skaiciuoti matricos elementu aritmetini vidurki
double vidurkis = matricos_elementu_vidurkis(matrica, x, y); // gaunam vidurki
cout << "Matricos aritmetinis vidurkis yra: " << vidurkis << "\n";
} else if (veiksmas == "4") { // pakeisti pasirinkta elementa nauja reiksme
int x1, y1;
double n;
cout << "Iveskite keiciamos eilutes nr: ";
cin >> x1;
cout << "\nIveskite keiciamo stulpelio nr: ";
cin >> y1;
if (cin.good()) {
cout << "\nIveskite nauja elemento reiksme: ";
cin >> n;
if (cin.good()) {
if (keisti_matricos_elementa_nauja_reiksme(matrica, x, y, x1, y1, n)) { // keicia elementa
cout << "\nElemento reiksme pakeista sekmingai \n\n";
spausdinti_matrica(cout, matrica, x, y);
} else {
cout << "Klaida! Toks matricos elementas neegistuoja";
}
}
}
} else if (veiksmas == "5") { // Rasti kiekvienos eilutes didziausia elementa
double nauja_matrica[100];
sukurti_matrica_pagal_atrinktus_elementus(matrica, nauja_matrica, x, y); // formuojam nauja matrica
cout << "Didziausi kiekvienos matricos eilutes elementai yra: \n\n";
for(int i = 0; i < y; i++) { // prasuka pro visas eilutes
cout << i + 1 << " eilutes didziausias elementas yar: " << nauja_matrica[i] << "\n"; // Y eilutes didziausias elementas yra: bla bla
}
} else if (veiksmas == "6") { // Sudauginti teigiamus elementus is eilutes, kurioje yra didziausias matricos elementas
//debug(x, y);
int eilute = gauti_eilute(matrica, x, y, 'd') + 1; // suranda kuri eilute turi didziausia elementa
cout << "Didziausias elementas yra " << eilute << " eiluteje.\n";
cout << eilute << " eilutes teigiamu elementu sandauga lygi: ";
cout << std::fixed << dauginti_teigiamus_elementus(matrica, eilute - 1, x) <<  "\n";
cout << resetiosflags( ios::fixed ) ;

} else if (veiksmas == "7") { // suranda stulpeli, kuriame yra didziausia suma neigiamu elementu
int id = neigiamiausias_stuleplis(matrica, x, y);
suformuoti_didziausiu_matricos_elementu_masyva(matrica, y, x, didziausi_elementai);
if (id == -1) {
cout << "Klaida! Neigiamu elementu matricoje nera\n";
} else {
cout << "Didziausia neigiamu elementu suma turintis stulpelis yra: " << id + 1 << "\n";
}
} else if (veiksmas == "8") { // sukeicia daugiausia neigiamu elementu turinti stulpeli su maziausiai turinciu
cout << "Sukeicia daugiausia neigiamu elementu turinti stulpeli su maziausiai turinciu\n";
if (sukeicia_min_max_stulpelius(matrica, x, y)) {// matricos stulpeliu sukeitimas
cout << "Stulpeliai sukeisti sekmingai\n\n";
spausdinti_matrica(cout, matrica, x, y);
} else {
cout << "Klaida! Teigiamu elementu matricoje nera\n";
}
}  else if (veiksmas == "9") {
spausdinti_matrica(cout, matrica, x, y); // spausdinam matrica ekrane
} else if (veiksmas == "10") { // spausdinam matrica i faila
cout << "Iveskite kelia iki failo: ";
cin >> kelias;
ofstream failas(kelias.c_str());
if (!failas.fail()) {
// irasom matricos dydi
failas << x << " ";
failas << y << "\n";
spausdinti_matrica(failas, matrica, x, y); // irasom matrica
cout << "\nMatrica sekmingai irasyta.\n";
} else {
cout << "Klaida! Blogas failas. Jis neegzistuoja arba yra pazeistas\n";
}
failas.close();
} else if (veiksmas == "11") {
int st;
cout << "Iveskite stulpeli, pagal kuri bus rikiuojama matrica didejimo tvarka: ";
cin >> st;
if (cin.good()) {
if (ar_egzistuoja_toks_matricos_elementas(y, x, 1, st)) {
rikiuoti_matrica(matrica, x, y, st - 1); // rikiuojam matrica
cout << "Matrica surusiuota\n\n";
spausdinti_matrica(cout, matrica, x, y); // spausdinam
} else {
cout << "Klaida! Sio stulpelio nera\n";
}
}
} else if(veiksmas == "13"){
// kvadratais pakeisti po maziausia elementa turincios eilutes
maziausiai_elementas_yra_sioje_eiluteje = gauti_eilute(matrica, y, x, 'm') + 1; // suranda kuri eilute turi didziausia elementa
cout << "Maziausias elementas yra " << maziausiai_elementas_yra_sioje_eiluteje << " eiluteje.\n";
keisti_neigiamus_elementus_kvadratais(matrica, y, x, maziausiai_elementas_yra_sioje_eiluteje);
cout << "Matricos elementai pakeisti.\n";
spausdinti_matrica(cout, matrica, x, y);
}
} else {
cout << "Klaida! Pries pasirinkdami si meniu punkta turite ivesti matrica!\n";
}
} else {
cout << "Klaida! Pasirinkote meniu punkta, kurio nera\n";
}
}
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;
}


// meniu punktai

void meniu() {
cout << "[0] Meniu\n"; // done
cout << "[1] Formuoti matrica is failo\n"; // done
cout << "[2] Formuoti matrica su klaviatura\n"; // done
cout << "[3] Skaiciuoti matricos elementu aritmetini vidurki\n"; // done
cout << "[4] Keisti matricos elementa\n"; // done
cout << "[5] Rasti kiekvienos eilutes didziausia elementa\n"; // done
cout << "[6] Sudauginti teigiamus elementus is eilutes, kurioje yra didziausias matricos elementas\n"; // done
cout << "[7] Surasti didziausia neigiamu elementu suma turinti matricos stulpeli\n"; // done
cout << "[8] Sukeisti vietomis maziausiai ir daugiausiai teigiamu elementu turincius stulpelius vietomis\n"; // done
cout << "[9] Spausdinti matricja\n"; // done
cout << "[10] Irasyti matrica i faila\n"; // done
cout << "[11] Rusiuoti matrica pagal pasirinkta stulpeli\n";
cout << "[12] Baigti darba\n"; // done
cout << "[13] Visose matricos eilutese, esanciose zemiau tos eilutes, kurioje yra maziausias matricos elementas, neigiamus pakeisti ju kvadratais";
}

void baigti() {
exit(0);
}


// gauna eilute spausdinimui matricos i konsole arba faila

void spausdinti_matrica(ostream &duomenys, double matrica[][100], int x, int y) {
duomenys.precision(3); // 3 skaiciu po kableliu tikslumu
for(int i = 0; i < y; i++) {
for(int j = 0; j < x; j++) {
duomenys.width(5); // duomeny plotis
duomenys.fill(' '); // duomenu pradinis uzpildymas
duomenys << matrica[i][j] << " "; // iveda matricos elemento reiksme
}
duomenys << "\n"; // pereina i nauja eilute
}
}

// suformuoja matrica

int formuoja_matrica(istream &duomenys, double (&matrica)[100][100], int x, int y) {
duomenys.precision(3); // tikslumas - 3 sk. po kablelio
for(int i = 0; i < y; i++) {
for(int j = 0; j < x; j++) {
duomenys >> matrica[i][j];
if (duomenys.fail()) // jei klaida - iseina is f-cijos su -1 o ne 1
return -1;
}
}
return 1;
}

// iveda matrica is failo

int iveda_matrica_is_failo(string kelias, double (&matrica)[100][100], int &x, int &y) {
int s = -1;
ifstream failas(kelias.c_str());
if (!failas.is_open()) { // atidarom
return -1;
}

failas >> x >> y; // gaunam eiluciu ir stulpeliu skaiciu
if (cin.good()) {
if (ar_egzistuoja_toks_matricos_elementas(100, 100, x, y)) {
s = formuoja_matrica(failas, matrica, x, y); // formavimas
}
}
failas.close(); // uzdarom
return s;
}

// matricos elementu vidurkis

void debug(int x, int y){
cout << "x: " << x << " Y: " << y;
}

double matricos_elementu_vidurkis(double matrica[][100], int y, int x) {
double suma = 0;
for(int i = 0; i < y; i++) {
for(int j = 0; j < x; j++) {
suma = suma + matrica[i][j];
}
}
return (double) suma / (y * x);
}

// grazina stuleplio id, kuris buvo neigiamiausias. t.y. sudeda neigiamus elementus ir palygina

int neigiamiausias_stuleplis(double matrica[][100], int x, int y) {
double suma[100], min;
int e = 0, id;

    // nulinam
for(int i = 0; i < 100; i++) {
suma[i] = 0;
}
// skaiciuojam stulpeliu neigiamu elementu suma
for(int i = 0; i < x; i++) {
for(int j = 0; j < y; j++) {
if (matrica[j][i] < 0) {
suma[i] = suma[i] + matrica[j][i];
e = 1;
}
}
}
if (!e) {
return -1;
}
// randam indeksa
min = suma[0];
id = 0;
for(int i = 0; i < x; i++) {
if (suma[i] < min) {
min = suma[i];
id = i;
}
}
return id;
}

// ar matricoje x y egzistuoja elementas x1 y1

bool ar_egzistuoja_toks_matricos_elementas(int x, int y, int x1, int y1) {
if (0 < x1 && x1 <= x && 0 < y1 && y1 <= y){ // x1 ir y1 turi buti [0...x] arba [0...y]
return true;
}
return false;
}


// grazina eilutes indeksa, kuri eilute turi didziausia arba maziausia elementa

int gauti_eilute(double matrica[][100], int x, int y, char ka_veikt) {
if (ka_veikt != 'd' && ka_veikt != 'm') { // ka daryt ar rast maziausia (m) ar didziausia (d)
// cout << "ka veitk: " << ka_veikt << "\n\n\n";
return -1;
}
int eilute = 0;
double n = matrica[0][0];
for(int i = 0; i < x; i++) {
for(int j = 0; j < y; j++) {
if (ka_veikt == 'd') {
if (matrica[i][j] > n) {
n = matrica[i][j];
eilute = i;
}
} else if (ka_veikt == 'm') {
if (matrica[i][j] < n) {
n = matrica[i][j];
eilute = i;
}
}
}
}
return eilute;
}

// sudaugina tieigiamus elementus pateiktos matricos

double dauginti_teigiamus_elementus(double matrica[][100], int y, int x) {
double sandauga = 1;
for(int i = 0; i < x; i++) {
if (matrica[y][i] > 0) {
sandauga = (double)sandauga * (double)matrica[y][i];
}
}
return sandauga;
}


// sukuria nauja matrica pagal atrinktus kiekvienos eilutes didziausius elementus

void sukurti_matrica_pagal_atrinktus_elementus(double (&matrica)[100][100], double (&nauja_matrica)[100], int y, int x) {
double max;
for(int i = 0; i < x; i++) {
max = matrica[i][0]; // didziausias pirmas elementas
for(int j = 0; j < y; j++) { // prasisuka pro visus eilutes elementus
if (matrica[i][j] > max) {
max = matrica[i][j];
}
}
nauja_matrica[i] = max; //formuoja nauja matrica
}
}


// keicia matricos elemento reiksme, taip pat patikrina ar tas elementas egzistuoja

bool keisti_matricos_elementa_nauja_reiksme(double (&matrica)[100][100], int x, int y, int x1, int y1, double reiksme) {
if (ar_egzistuoja_toks_matricos_elementas(x, y, y1, x1)) {
matrica[x1 - 1][y1 - 1] = reiksme;
return true;
}
return false;
}

//rikiavimas pagal pasirinkta stulpeli didejimo tvarka
void rikiuoti_matrica(double (&matrica)[100][100], int x, int y, int st) {
int mini = 0;
double min = matrica[0][0], tmp;
for(int i = 0; i < y; i++) {
for(int j = 0; j < y; j++) {
if (matrica[j][st] > matrica[i][st])  {
for(int k = 0; k < x; k++) {
tmp = matrica[i][k];
matrica[i][k] = matrica[j][k];
matrica[j][k] = tmp;
}
}
}
}
}


// sukeicia vietomis minimalu ir maksimalu stulpelius

bool sukeicia_min_max_stulpelius(double (&matrica)[100][100], int x, int y) {
int e[100], c = 0, mini, maxi;
double max, min, tmp;
//skaiciuojam kiek teigiamu elementu turi kiekvienas stulpelis
for(int i = 0; i < x; i++) {
e[i] = 0;
for(int j = 0; j < y; j++) {
if (matrica[j][i] > 0) {
e[i]++;
}
}
}
// randam stulpeli, kuriame daugiausiai teigiamu elementu
max = e[0];
maxi = 0;
for(int i = 0; i < x; i++) {
if (e[i] > max) {
max = e[i];
maxi = i;
}
}
if (max == 0) { // nera ne vieno teigiamo elemento
return false;
}

min = e[0];
mini = 0;
for(int i = 0; i < x; i++) {
if (e[i] < min) {
min = e[i];
mini = i;
}
}
// apkeiciam stulpelius vietomis
for(int i = 0; i < y; i++) {
tmp = matrica[i][maxi];
matrica[i][maxi] = matrica[i][mini];
matrica[i][mini] = tmp;
}
return true;
}



void suformuoti_didziausiu_matricos_elementu_masyva(double (&masyvas)[100][100], int y, int x,  double (&naujas_masyvas)[100]){
int didziausias;
for(int i = 0; i < y; i++){
didziausias = 0;
// randa didziausia sios eilutes
for(int j = 0; j < y; j++){
if(masyvas[i][didziausias] > masyvas[i][j]){
didziausias = j;
}
}
naujas_masyvas[i] = masyvas[i][didziausias];
}
}

void keisti_neigiamus_elementus_kvadratais(double (&masyvas)[100][100], int y, int x, int nuo_eilutes){
for(int i = nuo_eilutes; i < y; i++){
for(int j = 0; j < x; j++){
if(masyvas[i][j] < 0){
masyvas[i][j] = masyvas[i][j] * masyvas[i][j];
}
}
}
}

« Paskutinį kartą keitė: 2011-12-02 14:25:27 pm sukūrė Lukas Liesis »
Jūsų draugas, kolega ir puslapio administratorius,

Lukas.

Gerda Photography
Serveriai.lt 50% nuolaida!
Free Hosting
Free Templates

Manualai.lt Forumas

c++ darbai su masyvais pavyzdziai
« Įrašytas: 2011-12-02 14:23:24 pm »