Pseudokodi

 Algoritmet

(*Llogaritje e nje funksioni per nje vlere te dhene *)

Fillim

Lexo X0;

Y:=x0*x0+6*x0+2;

rezultati Y;

Fund.

    Algoritmet e degezuara

Algoritmat e degezuar jane ato lloj algoritmash ku perdoren veprimet e kushtezuara, pra kryhet ose

nje bashkesi veprimesh ose nje tjeter, ne varesi te vleres se nje kushti.

Nder veprimet e kushtezuara mund te permendim instruksionet:

1. ne qofte se… atehere

2. ne qofte se ….atehere…perndryshe

3. sipas…kryej

Shembulli nr 2

Te ndertohet nje algoritem qe lexon 2 numra per A dhe B dhe paraqet ne ekran me te madhin midis variablave?

Fillim

Algoritem Maksimum

Lexo A, B

Po Jo

A>B

(*gjetja e maksimumit*)

Fillim

Lexo (A, B);

n.qse (A>B) atehere

Max←A;

Perndryshe

Max←B;

shtyp (Max);

Fund.

-Algoritmet ciklike

Algoritma ciklike jane ato algoritme qe perdorin veprimet e perseritura ( veprimet ciklike) ose

1. derisa…kryej

2. perserit…gjersa

3. per…deri…kryej

 Pseudokodi-

ne program.

Fillimi

#include <iostream>

using namespace std;

#define per for

#define lexo cin

#define shtyp cout

#define MIN 1

#define MAKS 10

#define SHUMA a+b

#define Katrori(k) (a*a)

#define kthe return

int main()

 {

int i,a,b,k;

shtyp<<"Jepni vlerat per X1 dhe X2: ";

lexo>>a

 >>b;

shtyp<< "Shuma = a+b = "

 <<SHUMA

 <<"\n";

 shtyp<< "Katrori (h) = "

 << Katrori(k)

 <<"/n";

per(i=1;i<=10;i++)

shtyp << i

<< "\n";

 kthe 0;

 }

1.   Numerimi I zanoreve dhe bashketingelloreve ne nje varg shkronjash

Kodi:

#include <iostream>

using namespace std;

//Ky program kerkon nga perdoruesi te jape disa shkronja dhe pastaj numeron

//sa prej tyre jane zanore e sa bashketingellore. Numri i shkronjave qe do

//lexohen jepet ne fillim te programit nga perdoruesi

int main()

 int i, n;

 char shkronja;

 int zanore, bashkt;

 //Se pari kerkojme nga perdoruesi te tregoje sa shkronja do te jape

 cout << "Sa shkronja do te lexohen: ";

 cin >> n;

 //Inicializojme numrin e zanoreve ne 0

 zanore = 0;

 //Tani perseritim n here. Ne cdo perseritje lexojme nje shkronjenga

 //tastiera, kontrollojme nese eshte zanore dhe nese eshte ateherenumrin

 //e zanoreve e rrisim per 1.

 for (i = 1; i <= n; i++) {

 //Kerkojme nga perdoruesi te jape shkronjen

 cout << "Jepni shkronjen " << i << ": ";

 cin >> shkronja;

 //Kontrollojme nese eshte zanore, nese po rrisim numrin e zanoreveper 1

 switch (shkronja) {

 case 'a':

 case 'e':

 case 'ë':

 case 'o':

 case 'i':

 case 'u':

 case 'y': zanore++; break;

 }

 //Tani qe kemi mbaruar me leximin e dijme numrin e zanoreve

 //Numri i bashketingelloreve eshte numri i shkronja minus zanoret

 bashkt = n - zanore;

 //Shtypim rezultatin

 cout << "Gjithsejt jane lexuar " << zanore << " zanore " << endl;

 cout << "Gjithsejt jane lexuar " << bashkt << " bashketingellore";

=============================================================

2.   Numerimi I numrave cift dhe tek ne nje varg numrash

Kodi:

#include <iostream>

using namespace std;

//Ky program lexon nje varg numrash nga tastiera dhe numeron sa prej tyre

//cift e sa tek. Numri i numrave qe do te lexohen nuk dihet qe perpara dhe

//leximi do te perfundoje kur te lexohet ndonje numer negativ ose zero.

int main()

 int numri;

 int cift, tek; //Variabla qe do te mbajne numrin e numrave cift/tek

 //Inicializojme variablat cift dhe tek; numerimi fillon prej 0

 cift = 0;

 tek = 0;

 //Tani do te perserisim pandalur duke lexuar numra, do te kontrollojme

 //nese jane cift ose tek. Ndalimi i perseritjes do te behet prej brenda

 //ciklit me ane te urdherit break, kur do te lexohet numer <= 0

 while (true) {

 //Lexo numrin

 cout << "Jep numrin: ";

 cin >> numri;

 //Kontrollo nese eshte me i vogel ose i barabarte se 0. Nese po,

 //perseritjen duke perdorur urdherin break

 if (numri <= 0) {

 break;

 }

 //Tani kontrollojme nese numri eshte cift ose tek dhe rrisimnumerimin

 //e numrave cift ose tek. Kete e bejme duke krahasur mbetjen gjate

 //pjesetimit te atij numri me 0

 if ((numri % 2) == 0) {

 //Nese mbetja eshte 0, atehere eshte numer cift

 cift++;

 } else {

 //Perndryshe eshte numer tek

 tek++;

 }

 } //mbyll urdherin while

 //Na ka mbetur vetem ti shtypim rezultatet

 cout << "Gjithsejt jane lexuar " << cift << " numra cift\n";

 cout << "Gjithsejt jane lexuar " << tek << " numra tek";

 return 0;}

========================================================= 

3.   Llogaritja e fuqise

Kodi:

#include <iostream>

using namespace std;

//Shenja ^ ketu dmth fuqizim

//Ky program lexon dy numra (x dhe exp) nga perdoruesi dhe pastaj llogarit

//vleren e numrit x ne fuqine exp, dmth x^exp. Kete do ta bejme duke marre

//parasysh se x^exp do me thene qe x ta shumezojme 'exp' here me vetveten

//x^exp = x*x*x....*x exp here

6

int main()

 int i;

 int exp; //Fuqia mund te jete vetem numer i plote

 double x; //Baza mund te jete edhe numer real

 double p; //Edhe rezultati mund te jete numer real

 //Lexojme bazen dhe fuqine

 cout << "Sa eshte baza x= ";

 cin >> x;

 cout << "Sa eshte fuqia exp= ";

 cin >> exp;

 //Inicializojme rezultatin ne 1, pasi behet fjale per prodhim

 p = 1;

 //Tani do te perserisim exp here, dhe cdo here do ta shumezojme x me

 //vetveten

 for (i = 1; i <= exp; i++) {

 p = p * x;

 //Shtypim rezultatin

 cout << x << " ^ " << exp << " = " << p;

 return 0;

=============================================================

4.   Algoritmi I Euklidit per gjetjen e pjesetuesit me te madh te perbashket

Kodi:

#include <iostream>

using namespace std;

//Ky program llogarit pjesetuesin me te madh te perbashket te dy numrave te

//dhene duke perdorur algoritmin e Euklidit. Me kete algoritem vazhdimisht

//zbresim numrin me te vogel nga me i madhi derisa te dy numrat te jene te

//barabarte. Kur numrat te jene te barabarte, atehere ajo vlere eshte

rezultati

int main()

 int num1, num2; //Numrat qe do te jepen

 //Leximi i numrave

 cout << "Jepni numrin e pare: ";

 cin >> num1;

 cout << "Jepni numrin e dyte: ";

 cin >> num2;

 //Tani do te perserisim perderisa numrat jane te ndryshem

 while (num1 != num2) {

 //Krahasojme numrat, zbresim me te voglin nga me i madhi

 if (num1 > num2) {

 num1 = num1 - num2;

 } else {

 num2 = num2 - num1;

 }

7

 //Kur te mberrijme ketu dmth se num1 dhe num2 jane tash te barabarte

 //Vlera e tyre eshte rezultati, qe e shtypim

 cout << "PMP = " << num1;

 return 0;

=============================================================

5.   Llogaritja e numrit te kundert te nje numri, mandej mbledhja e tij me 50

Kodi:

#include <iostream>

using namespace std;

//Ky program llogarit numrin e kundert te nje numri, mandej e mbledh ate me

//P.sh. nese jepet numri 12345, atehere llogaritim 54321+50

int main()

 int x; //Numri qe do te jepet

 int y; //Numri i kundert qe do ta ndertojme

 int shifra;

 //Nisim ta ndertojme numrin e kundert duke filluar nga 0

 y = 0;

 //Se pari lexojme numrin qe do ta kthejme mbrapsht

 cout << "Jepni numrin x= ";

 cin >> x;

 //Tani do te perserisim derisa numri x te behet 0. Ne cdo perseritje

 //do te nxjerrim shifren e fundit nga numri x dhe ate shifer do t'ia

shtojme

 //numrit y qe e ndertojme.

 while (x > 0) {

 //Nxjerr shifren e fundit, duke llogaritur mbetjen me 10

 shifra = x % 10;

 //Tash ate shifer vendose si shifer e fundit te numrit te kundert

 y = y * 10 + shifra;

 //Hiq shifren e fundit nga numri x duke pjesetuar me 10

 x = x / 10;

 //Tani qe e kemi numrin e kundert, vetem shtoji atij 50

 y += 50; //Njesoj si y = y + 50

 //Shtyp rezultatin

 cout << "Numri i kundert plus 50 eshte y=" << y;

 return 0;

========================================================= 

6.   Shuma e n numrave te pare te Fibonacit

Kodi:

#include <iostream>

using namespace std;

//Ky program llogarit shumen e n numrave te pare te Fibonaccit. Programi

eshte

//i ngjashem me programin nr.5 nga permbledhja nr.2, por ketu kur

llogaritim

//numrat e Fibonaccit ne vend qe ti shtypim ne ekran jua shtojme shumes

int main()

 int i; // Variabel qe do ta perdorim per te shenuar pozicionin ku

gjendemi

 // ne vargun e Fibonaccit, duke filluar nga 3

 int fib; // Mban vleren e Fibonaccit qe do te llogaritet

 int fiba; //Mban vleren e parafundit te llogaritur te Fibonaccit

 int fibb; //Mban vleren e para-parafundit te llogaritur te Fibonaccit

 int n; //Deri ne cilen pozite do te llogariten numrat e Fibonaccit

 int shuma;

 //Leximi i n; dmth deri ne cilen pozite do te llogariten numrat e

Fibonaccit

 cout << "Deri ne cilin numer te Fibonaccit te behet llogaritja: ";

 cin >> n;

 //Inicializimi i variablave

 fiba = 1; //Pasi nisim me i=3; numri i dyte i Fibonaccit eshte 1

 fibb = 1; //Pasi nisim me i=3; numri i pare i Fibonaccit eshte 1

 shuma = 2; //Pasi nisim me i=3, shumen do ta nisim nga mbledhja e dy

numrave

 //te pare te Fibonaccit, dmth shuma=1+1=2

 //Nis nga i=3 dhe llogarit numrat e Fibonaccit deri ne n

 for (i = 3; i <= n; i++) {

 // Llogarit numrin e Fibonaccit

 fib = fiba + fibb;

 //Numrin e llogaritur shtoja shumes

 shuma += fib; //Njelloj si shuma=shuma+fib

 //Pasi kemi llogaritur numrin e ri te Fibonaccit, i ecim para edhe

 //numrat e meparshem te llogaritur

 fibb = fiba;

 fiba = fib;

 //Shtypim rezultatin

 cout << "Shuma e " << n << " numrave te pare te Fibonaccit eshte " <<

shuma;

 return 0;

=======================================================

Përmbledhje 2 (for, while)

[/b]

Ne vijim gjenden disa shembuj ne C++ qe I kemi punuar edhe ne ushtrime gjatë javës se kaluar.

Nëse keni ndonjë pyetje rreth shembujve te mëposhtëm, lirisht mund te me drejtoheni nëpërmjet e-

mailit ose ne ushtrime.

=========================================================

1.   Llogaritja e shumes se numrave prej 1 deri n me urdhërin ‘for’

Kodi:

#include <iostream>

using namespace std;

//Ky program llogarit shumen e numrave prej 1 deri ne N duke perdorur

urdhërin //'for'

int main()

 //Deklarimi i variablave

 int i, n;

 int S;

 //Leximi i n, d.m.th. perdoruesi do të jape numrin deri ne te cilin

duhet te

 //kryhet mbledhja

 cout << "Deri ne cilin numer duhet te kryhet mbledhja: ";

 cin>>n;

 //Inicializo shumen ne 0. i nuk ka nevojë te inicializohet këtu,

pasi i

 //është parameter kontrollues, qe inicializohet ne vete

urdhërin 'for'

 S = 0;

 //Duke filluar nga i=0 deri ne i=n shtoji shumes vleren e i

 for (i = 1; i <= n; i++) {

 S = S + i;

 }

10

 //Shtypja e rezultatit

 cout << "Shuma e numrave prej 1 deri ne " << n << " është " << S;

==========================================================

====

2.   Llogaritja e shumes se numrave prej 1 deri n me urdhërin ‘while’

Kodi:

#include <iostream>

using namespace std;

// Ky program llogarit shumen e numrave prej 1 deri ne N duke perdorur

urdhërin

// 'while'

int main()

 //Deklarimi i variablave

 int i, n;

 int S;

 //Leximi i n, d.m.th. perdoruesi do të jape numrin deri ne te cilin

duhet te

 //kryhet mbledhja

 cout << "Deri ne cilin numer duhet te kryhet mbledhja: ";

 cin>>n;

 //Inicializo shumen ne 0. Pasi te urdhëri 'while' nuk ka vend te

caktuar ku

 //bëhet inicializimi i parametrit kontrollues, këtë duhet ta bëjmë

vete para

 //fillimit te perseritjes

 S = 0;

 i = 1;

 //Shtoja vleren i shumes S, përderisa i <= n

 while (i <= n) {

 S = S + i;

 //Edhe për rritjen e 'i' nuk ka vend te caktuar kështuqë e bëjmë

këtu

 i++;

 }

 //Shtypja e rezultatit

 cout << "Shuma e numrave prej 1 deri ne " << n << " është " << S;

=========================================================

3.   Shtypja e tabeles se shumezimit me një numer te dhënë

Kodi:

11

#include <iostream>

using namespace std;

// Ky program shtyp tabelen e shumezimit me një numer 'numri' te dhënë

// nga perdoruesi. Programi do të shfrytezoje urdhërin 'while'

int main()

 //Deklarimi i variablave

int i, numri;

int p; //Do te mbaje vleren e prodhimit 'i' me numrin e

dhënë 'numri'

// Leximi i 'numri'; d.m.th. këtu perdoruesi do të tregoje se

për cilin numer

// don te shtypet tabela e shumezimit

cout << "Për cilin numer te shtypet tabela e shumezimit: ";

cin >> numri;

//Inicializimi i variablave

i = 1;

// Perseritja përderisa i është me e vogël ose e barabarte me 10

// Ne çdo përsëritje do të llogaritim dhe shtypim prodhimin e

vleres

// se i me numrin e dhënë

while (i <= 10) {

 //Llogarit prodhimin

 p = numri * i;

 //Shtyp prodhimin

 cout << numri << " * " << i << " = " << p << endl;

 //Rrit i-ne

 i++;

}

========================================================= 

4.   Shtypja e tabeles se shumezimit me numrat 1 deri 10

Kodi:

#include <iostream>

using namespace std;

// Ky program shtyp tabelen e shumezimit nga 1 deri 10

// Programi do të shfrytezoje urdhërin 'for'

int main()

 //Deklarimi i variablave

int i, j; // Këtu do të na duhen dy variabla për përsëritje

12

int p; //Do te mbaje vleren e prodhimit

// Për çdo 'j' nga 1 deri 10 bëj shtypjen e tabeles se

shumezimit me atë

// numer 'j'

for (j = 1; j <= 10; j++) {

 for (i = 1; i <= 10; i++) {

 //Llogarit prodhimin e vleres se tashmë te i me vleren

e tashmë te j

 p = i * j;

 //Shtyp vleren e prodhimit

 cout << i << " * " << j << " = " << p << endl;

 }

}

==========================================================

====

5.   Shtypja e numrave te Fibonaccit deri ne numrin e dhënë ‘n’

Kodi:

#include <iostream>

using namespace std;

// Ky program bën shtypjen e numrave te Fibonaccit (d.m.th. atë qe quhet

vargu i

// Fibonaccit), deri ne numrin e dhënë numri

int main()

 //Deklarimi i variablave

 int i; // Variabel qe do ta perdorim për te shënuar pozicionin ku

gjendemi

 // ne vargun e Fibonaccit, duke filluar nga 3

 int fib; // Mban vleren e Fibonaccit qe do të llogaritet

 int fiba; //Mban vleren e parafundit te llogaritur te Fibonaccit

 int fibb; //Mban vleren e para-parafundit te llogaritur te

Fibonaccit

 int n; //Deri ne cilën pozite do të llogariten numrat e Fibonaccit

 //Leximi i n; d.m.th. deri ne cilën pozite do të llogariten numrat e

Fibonaccit

 cout << "Deri ne cilin numer te Fibonaccit te bëhet llogaritja: ";

 cin >> n;

 //Inicializimi i variablave

 fiba = 1; //Pasi nisim me i=3; numri i dytë i Fibonaccit është 1

 fibb = 1; //Pasi nisim me i=3; numri i parë i Fibonaccit është 1

 //Shtyp dy numrat e pare te Fibonaccit, qe janë baraz me 1

 cout << "1" << endl << "1" << endl;

 //Nis nga i=3 dhe llogarit numrat e Fibonaccit deri ne n

 for (i = 3; i <= n; i++) {

 // Llogarit numrin e Fibonaccit

 fib = fiba + fibb;

 //Shtyp numrin e llogaritur

 cout << fib << endl;

 //Pasi kemi llogaritur numrin e ri te Fibonaccit, i ecim para

edhe dy

 //numrat e meparshem te llogaritur

 fibb = fiba;

 fiba = fib;

 }

Informatika

 Programim  II