cu legere info pascal

1

C U L E G E R E D E P R O B L E M E

A U T O R I : p r o f . A l i n a C â l ţ a n p r o f . D a n i e l C o d r e ş p r o f . G e o r g e t a M a n a f u p r o f . A n t o a n e l a B ă l u ţ ă p r o f . D a n i e l a H a s s a n C o o r d o n a t o r : p r o f . T a n ţ a N e g r o i u D r ă g h i c i

2

P r e f a ţ ă

I e r a rh i a l imba j e l o r de p rog ramare e s t e î n z i l e l e noas t r e deoseb i t d e boga tă ş i v a r i a tă . Ea s e poa t e desc r i e c e l ma i c o r e c t î n t r -un spa ţ i u mu l t i d imens i ona l î n ca r e d imens iun i l e sun t r ep r e z en ta t e de ca rac t e r i s t i c i l e l imba j e l o r . Î n aceas tă i e r a rh i e l imba ju l Pasca l o cupă un l o c spec i a l p r in f ap tu l că e s t e l e ga t de concep tu l de s t ruc tu ra r e a p rog rame lo r . Î n pe r i oada 1960 - 1970 u t i l i z a r ea in t ens i vă a i n s t ruc ţ i un i l o r de sa l t necond i ţ i ona t a condus l a apa r i ţ i a p r og rame lo r de t i p " spaghe t t i " i n c r ed ib i l d e comp l exe , g r eu de în ţe l e s ş i d e mod i f i c a t . Un moment impor t an t a f o s t o f e r i t d e anu l 1966 când s -a demons t ra t că p en t ru o r i c e p r og ram ca r e u t i l i z ea ză i n s t ruc ţ i un i de sa l t necond i ţ i ona t ex i s tă un p rog ram ech i va l en t , c a r e u t i l i z ea ză numa i s t ruc tu r i l e i f ş i wh i l e . P e l i n i a a ces t o r p r eocupă r i a l e v r em i i , N i cko l aus W i r th a in t r odus în 1971 l imba ju l Pasca l . Scopu l i n i ţ i a l a f o s t d e a p r e z en ta un l imba j ca r e să p r omoveze t ehn i c i l e de p rog ramare s t ruc tura tă . An i i c a r e au u rmat au a ră t a t că a c es t l imba j a f o s t r epede as im i l a t î n lumea ca l cu l a t oa r e l o r ş i a rămas ca op ţ i une a mu l t o ra d in t r e i n f o rma t i c i en i . Ma i mu l t , p en t ru ca l i tă ţ i l e sa l e e l e s t e ş i a s tă z i o op ţ i une a i ns t i tu ţ i i l o r a cademice , f a cu l tă ţ i l o r , şco l i l o r ş i nu numa i .

Luc ra r ea de f a ţ ă nu e s t e o s imp lă cu l e ge r e de p rob l eme ş i n i c i o cu l e ge r e de t e s t e pen t ru p rog ramarea în l imba ju l Pasca l , aşa cum s -a r pă r ea l a p r ima v ede r e . S t ruc tu ra tă p e t r e i c ap i t o l e , l uc ra r ea r euşeş t e să su rp r indă p r inc ipa l e l e e l emen te l e ga t e de abo rda rea a l go r i tm i că a r e zo l vă r i i uno r p rob l eme cu ca l cu la t o ru l ş i să s in t e t i z e z e a spec t e l e fundamenta l e a l e p r og ramă r i i î n l imba ju l Pasca l . Me r i tu l p r inc ipa l a l a c es t e i că r ţ i c ons tă î n t r a t a r ea g rada tă a no ţ i un i l o r , c onc i z iunea ş i r i g oa r ea expuner i i . P r in a l e g e r ea făcu tă cu p r i v i r e l a p rob l eme l e t r a t a t e , s - a r ea l i z a t o l e gă tu ră na tu ra lă ş i d i r e c tă cu manua l e l e de ma temat i că d in g imnaz iu . C i t i t o ru l va i den t i f i c a uşo r p rob l eme l e l e ga t e de d i v i z i b i l i t a t e , c e l ma i mare d i v i z o r c omun , c e l ma i m i c mu l t i p lu comun , f r a c ţ i i , a r i i , v o lume . Ex i s tă , aşadar , su f i c i en t e mo t i v e să c r edem că p en t ru c e l ca r e va avea cu r i o z i t a t ea ş i răbdarea să pa r curgă a c es t ma t e r i a l s e v o r lămur i mu l t e d in t a ine l e p rog ramă r i i c a l cu la t o ru lu i . Ş i a c es ta e s t e numa i un începu t , d eoa rece de înda tă c e a i r euş i t să d escu i s e c r e t e l e p rog ramă r i i , e s t e f oa r t e g r eu să r enun ţ i l a d rumul ca r e ţ i s e desch ide .

P r o f . u n i v . d r . N i c o l a e Ţ ă n d ă r e a n u

Culegere de probleme

167

C U P R I N S

Capitolul 1: Noţiuni introductive 1.1. Rezolvarea unei probleme cu ajutorul calculatorului………………………………………………………………………………………………..…….4 1.2. Introducere în l imbajul Turbo Pascal 1.2.1. Identificatori. Constante. Tipuri de date. Variabile. Expresii……………………………………………………………………………………………….7 1.2.2. Citirea/scrierea datelor……………………………………………………………………………………………………………………………………………12 Răspunsuri……………………………………………………………………………………………………………………………………………………………………17 Capitolul 2: Structuri de control 2.1. Structura l iniară…………………………………………………………………………………………………………………………………………………………...20 2.1.1. Teste……………………………………………………………………………………………………………………………………………………………………24 2.1.2. Probleme propuse…………………………………………………………………………………………………………………………………………………..27 Răspunsuri……………………………………………………………………………………………………………………………………………………………………28 2.2. Structura alternativă 2.2.1. Instrucţiunea if……………………………………………………………………………………………………………………………………………………...31 2.2.2. Teste……………………………………………………………………………………………………………………………………………………………………41 2.2.3. Probleme propuse………………………………………………………………………………………………………………………………………………..…44 2.2.4. Instrucţiunea case………………………………………………………………………………………………………………………………………………….45 2.2.5. Teste……………………………………………………………………………………………………………………………………………………………………50 2.2.6. Probleme propuse…………………………………………………………………………………………………………………………………………………..54 Răspunsuri……………………………………………………………………………………………………………………………………………………………………55 2.3. Structura repetitivă 2.3.1. Instrucţiunea while………………………………………………………………………………………………………………………………………………..63 2.3.2. Probleme propuse…………………………………………………………………………………………………………………………………………………..69 2.3.3. Instrucţiunea repeat……………………………………………………………………………………………………………………………………………….76 2.3.4. Probleme propuse…………………………………………………………………………………………………………………………………………………..82 2.3.5. Instrucţiunea for……………………………………………………………………………………………………………………………………………………88 2.3.6. Probleme propuse…………………………………………………………………………………………………………………………………………………..94 2.3.7. Teste while……………………………………………………………………………………………………………………………………………………………99 2.3.8. Teste repeat………………………………………………………………………………………………………………………………………………………..101 2.3.9. Teste for……………………………………………………………………………………………………………………………………………………………..103 Răspunsuri…………………………………………………………………………………………………………………………………………………………………..105 Capitolul 3: Tipul tablou 3.1. Tablouri unidimensionale - vectori………………………………………………………………………………………………………………………………109 3.1.1. Teste………………………………………………………………………………………………………………………………………………………………….119 3.1.2. Probleme propuse…………………………………………………………………………………………………………………………………………………123 Răspunsuri………………………………………………………………………………………………………………………………………………………………….126 3.2. Tablouri bidimensionale - matrici.………………………………………………………………………………………………………………………………147 3.2.1. Teste………………………………………………………………………………………………………………………………………………………………….155 3.2.2. Probleme propuse…………………………………………………………………………………………………………………………………………………158 Răspunsuri…………………………………………………………………………………………………………………………………………………………………..159

Culegere de probleme

BIBLIOGRAFIE

Limbajul Pascal Doina Rancea Editura Computer Libris Agora 1997 Informatică Manual pentru clasa a IX-a Profilul matematică-informatică

Bogdan Pătruţ, Mariana Miloşescu, Editura Teora. Matematică Manual pentru clasa a V-a

G.Turcitu, C. Basarab, T.Dragonu; N.Ghiciu, I.Rizea, Ş.Smarandache, Editura RADICAL 1997 Matematică Manual pentru clasa a VI-a,

G.Turcitu, I.Rizea, I.Chiriac, C. Basarab, M. Duncea, P.Ciungu, Editura RADICAL 1998 Gazeta de informatică Matematică - culegere de probleme; Cărbunaru

168

Culegere de probleme Noţiuni introductive

Capitolul 1.

NOŢIUNI INTRODUCTIVE

1.1. Rezolvarea unei probleme cu ajutorul calculatorului.

Prezentarea etapelor de rezolvare a unei probleme cu ajutorul calculatorului. Descrierea schemei logice şi a pseudocodului. Prezentarea structurilor de control.

1.2. Introducere în limbajul Turbo Pascal. 1.2.1. Identificatori. Constante. Tipuri de date. Variabile. Expresii.

Se propun spre rezolvare 5 teste grilă.

1.2.2. Citirea/scrierea datelor. O scurtă prezentare a procedurilor de citire/scriere. Sunt prezentate exemple şi se propun spre rezolvare 3 teste.

3


1.1. Rezolvarea unei probleme cu ajutorul calculatorului. Pentru ca un calculator să rezolve o problemă trebuie executat un program. Realizarea unui program presupune parcurgerea etapelor: analiza problemei, descrierea algoritmului de rezolvare, elaborarea programului şi verificarea programului. Analiza problemei constă în determinarea datelor iniţiale ale problemei (le vom numi date de intrare), a rezultatelor problemei (le vom numi date de ieşire) şi descrierea metodei de rezolvare a problemei (o vom numi funcţia programului). Descrierea algoritmului de rezolvare constă în determinarea algoritmului ce rezolvă problema dată. Pentru descrierea algoritmilor există două forme de prezentare: schema logică şi pseudocodul (sau limbajul algoritmic). Schema logică este reprezentată prin figuri geometrice, specifice fiecărui tip de operaţie, legate între ele prin săgeţi pentru a evidenţia ordinea de execuţie a operaţiilor. În interiorul figurii geometrice se scrie operaţia corespunzătoare, acest ansamblu formând un bloc. Astfel, într-o schemă logică pot să apară blocurile: a) de start şi de stop

4

b) de citire c) de scriere

d) de atribuire e) de decizie

De asemenea, în descrierea schemei logice se folosesc conectori pentru a lega grupuri de blocuri. Aceştia au următoarea formă: unde n este numărul conexiunii. Pseudocodul (sau limbajul algoritmic) este alcătuit din instrucţiuni care încep, în general, cu un cuvânt cheie care defineşte operaţia de bază din algoritm. Instrucţiunilor pseudocodului le corespund instrucţiuni din limbajele de programare, ceea ce uşurează transcrierea algoritmului într-un program al unui limbaj de programare. Fiecare algoritm va fi prezentat sub forma unei secvenţe de text, pe care o vom numi procedură. Aceasta va începe cu numele său şi va fi urmată de cuvântul înseamnă. Instrucţiunile vor fi despărţite de ; şi încadrate de cuvintele început şi sfârşit; de asemenea, aceste cuvinte pot grupa mai multe instrucţiuni formând o instrucţiune compusă.

START STOP

Citeşte listă de variabile

Scrie listă de ex presii

variabilă expresie

condiţieNU DA

n n


Instrucţiunile pseudocodului sunt: 1) Instrucţiunea de atribuire. Are forma variabila :=expresie. Variabila primeşte valoarea expresiei. 2) Instrucţiunea de citire. Are forma Citeşte(v1, v2, …, vn). Citeşte valori pentru variabilele v1, v2, …, vn. 3) Instrucţiunea de scriere. Are forma Scrie(e1, e2, …, en). Afişează valorile expresiilor e1, e2, …, en. 4) Instrucţiunea de ramificare. Are forma dacă condiţie atunci instrucţiune1 altfel instrucţiune2.. Se testează condiţia dată şi se execută instrucţiunea instrucţiune1 dacă condiţia este adevărată, respectiv instrucţiune2 dacă condiţia nu este adevărată. Ramura altfel instrucţiune2 este opţională. Dacă lipseşte, înseamnă că nu se execută nimic dacă condiţia nu este adevărată. 5) Instrucţiunea de ciclare cât timp. Are forma cât timp condiţie execută instrucţiune. Se testează condiţia şi dacă este falsă instrucţiunea se opreşte, iar dacă este adevărată se execută instrucţiunea şi se continuă cu testarea condiţiei din nou. Pentru a descrie algoritmi clari trebuie respectate regulile de concepere a algoritmilor conform principiilor programării structurate.Pentru aceasta se utilizează trei structuri de control: secvenţială (secvenţa), alternativă (decizia) şi repetitivă (ciclul). Structura secvenţială: instrucţiune1; instrucţiune2; ………………..

5

instrucţiunen

Structura alternativă: dacă condiţie atunci instrucţiune1 altfel instrucţiune2

Structura repetitivă: cât timp condiţie execută instrucţiune

Programarea structurată poate folosi alte structuri de control pentru elaborarea algoritmilor. Acestea sunt: structura alternativă multiplă, structura repetitivă cu test final şi structura repetitivă cu contor. Structura alternativă multiplă

în caz că expresie este expr1 : instrucţiune1; expr2 : instrucţiune2; … exprn : instrucţiunen:

Instrucţiune1

Instrucţiune2

condiţieDA NU

Instrucţiune1 Instrucţiune1

condiţieDA NU

instrucţiune


6

altfel instrucţiunen+1 gata Structura repetitivă cu test final repetă instrucţiune1; instrucţiune2; … instrucţiunen;

până când condiţie Structura repetitivă cu contor pentru x := expresie1 la expresie2 [cu pasul p ] execută instrucţiune Observaţie: În cazul în care p=1, atunci nu se mai specifică pasul.

Elaborarea programului înseamnă transcrierea algoritmului obţinut într-un program al unui limbaj de programare. În

lucrarea de faţă, vom folosi limbajul de programare Turbo Pascal. Verificarea programului reprezintă introducerea mai multor date de intrare şi corectarea erorilor găsite cu acest prilej.


1.2. Introducere în limbajul Turbo Pascal. 1.2.1. Identificatori. Constante. Tipuri de date. Variabile. Expresii.

TEST 1

T1.1 Indicaţi identificatorii utilizator incorecţi: a) 2x b) sol c) _sol d) doi

e) x1+x2 f) trei& g) trei h) x* T1.2 Specificaţi constantele întregi: a) 200 b) –200 c) 89.4 d) 2e

e) 2.0 f) 6/2 g) 6785 h) 0.2 T1.3 Care din următoarele constante întregi sunt incorecte? a) 223.8 b) –345 c) 67 d) 2E4 T1.4 Care din următoarele constante reale sunt corecte? a) 2e-4 b) 234 c) 12.0

d) 0 e) 45E2 f) 451.95 T1.5 Indicaţi expresiile pentru care tipul rezultatului evaluării este întreg: a) 50/2 + 10 b) 51 mod 2 + 3*24 – 10

c) 45 div 7 >= 0 d) 75 - 50 = 25

T1.6 Să se indice expresiile a căror valoare de adevăr este true: a) ord(true) < ord(false) b) abs(2) > 4

c) sqr(25) < 5 d) odd(33) T1.7 Să se indice expresiile a căror valoare este false: a) ord(false) > ord(true) b) odd(67)

c) sqrt(25) <= 5 d) sqr(13) > sqrt(13) T1.8 Fie x=7.5, y=3, z=5, u=true şi v=false. Indicaţi expresiile pentru care tipul rezultatului evaluării este boolean: a) (x > 9) and ((y>1) or v) b) u or v

c) z mod y = 2 d) x + y + z < 20 T1.9 Se consideră condiţia logică: amândouă variabilele a şi b au valoarea true. Specificaţi modul de scriere al acesteia în limbajul Pascal. a) a or b; b) b and a;

c) (a=true) or (b=true); d) a and b.

7


TEST 2

T2.1 Indicaţi identificatorii utilizator incorecţi: a) y9 b) unu_ c) 56 d) zero

e) k1 f) d&g g) min h) n! T2.2 Specificaţi constantele întregi: a) -4579 b) 0.0 c) +67 d) 6+9

e) 0 f) –75.0 g) 100 h) 99e T2.3 Care din următoarele constante întregi sunt incorecte? a) +5674 b) +9.0 c) -45 d) 784 T2.4 Care din următoarele constante reale sunt incorecte? a) 78 b) 0.0 c) +56.98

d) 3e9 e) -87 f) 1E-10 T2.5 Indicaţi expresiile pentru care tipul rezultatului evaluării este întreg: a) 67 mod 9 > 2 b) 45 + 19 = 64

c) 45 + 5 – 9/3 d) (34 div 7) * (82 mod 9)

T2.6 Să se indice expresiile a căror valoare este true: a) (sqr(9) = 81) or (sqrt(9) = 3) b) abs(-56) >= 4

c) not (56 div 9 <=7) d) not odd(876)

T2.7 Să se indice expresiile a căror valoare este false: a) not (-5 < 5) and (-4 < 4) b) sqrt(144) > 10

c) not (sqr(4) < sqr(5)) d) abs(-8) > abs(-4) e) (-3 >0) or (3<0) f) not (sqr(3)<10)

T2.8 Fie A=65, B=’B’, C=’C’, D=’D’ şi q=true. Indicaţi expresiile pentru care tipul rezultatului evaluării este char: a) chr(A); b) succ(B) = C;

c) ord(D); d) (chr(A)=’A’) = q; e) pred(C); f) chr(ord(succ(D))).

T2.9 Se consideră condiţia logică: toate variabilele x, y, z sunt pozitive. Specificaţi modul de scriere al acesteia în limbajul Pascal.

a) x and y and z; b) (x >= 0) and (y>=0) and (z>=0); c) (x>0) and (y>0) and (z>0); d) (x>0) or (y>0) or (z>0).

T2.10. Se consideră expresia:

2y)*(x+y*x+y+x*y)+(x Care este modul de scriere al acesteia în limbajul Pascal? a) (x+y)*sqr(x+y)+x*y+sqrt(x*y); b) (x+y)*sqrt(x+y)+x*y+sqr(x*y).

8


TEST 3

T3.1 Indicaţi identificatorii utilizator corecţi: a) craiova b) Elena Cuza c) 13

d) treisprezece e) salut f) identificator g) salut! h) hgjfjlsd i) integer

T3.2 Care din următoarele definiţii de tipuri specifică zilele lucrătoare ale săptămânii:

a) type zi=(luni, marţi, miercuri, joi, vineri); b) type zi_lucrătoare=(luni, marţi, miercuri, joi, vineri); c) (luni, marţi, miercuri, joi, vineri).

T3.3 Se consideră următoarea declaraţie: Var a : (alb, gri, negru); Alegeţi tipul corect al variabilei a. a) subdomeniu; b) byte; c) enumerare. T3.4 Se consideră următoarea declaraţie: Var a : 0..9; Alegeţi tipul corect al variabilei a. a) integer; b) byte; c) subdomeniu. T3.5 Fie declaraţiile: Var n, m, o : longint;

Indicaţi expresiile corecte.

a) n and m and o b) n div m / 2 c) succ(o)+succ(m)+succ(n) d) (m shl 3) or (n shr 3) e) (m/2 div n) + (n/2 div m) f) m>0 and n>0 and o>0

T3.6 Indicaţi definiţiile de constante corecte:

a) const EC=’Colegiul Naţional Elena Cuzas Craiova’; b) Const nota : byte = 3; c) const trei=5; d) const var=0; e) const k=1.5; f) const litera=’A’.

T3.7 Să se specifice declaraţiile de variabile corecte:

a) var fffggg : integer; b) var t1, t2, t3 : 0..9; c) var x, y : real; m, n : byte; d) var f, g : single, i, j : char; e) var sol1, sol2 : double; culori : (roşu, verde); f) var x1, x2 : shortint;

y1, y2 : ‘a’..’z’; z1, z2 : word;

T3.8. Se consideră condiţia logică: fracţia x/y este subunitară. Care este modul de scriere al acesteia în limbajul Pascal? a) ((x/y)<1); b) (x/y)<1 and (x/y)>0; c) abs(x)<abs(y); d) ((x/y)<1) or ((x/y)>0).

9


TEST 4

T4.1 Se consideră următoarea declaraţie: Var a : (iarna, primavara, vara, toamna); Alegeţi tipul corect al variabilei a. a) char; b) string; c) enumerare. T4.2 Se consideră următoarea declaraţie: Var litere : ‘A’..’Z’; Alegeţi tipul corect al variabilei litere. a) subdomeniu; b) char; c) enumerare. T4.3 Care dintre următoarele definiţii de tipuri specifică corect cifrele zecimale:

a) type cifra=(0,1,2,3,4,5,6,7,8,9); b) type cif=0..9; c) type cifra={0,1,2,3,4,5,6,7,8,9}; d) type type cifra=1..9;

T4.4. Se consideră următoarea declaraţie: Var j : (rosu, galben, albastru); Să se specifice tipul variabilei j.

a) char; b) enumerare; c) string. T4.5. Fie declaraţiile:

Var x, y, z : real; Indicaţi expresiile corecte.

a) ((x +y+z) div 3)+ ((x +y+z) mod 3); b) x and y and z; c) not (x*y*z)+x*y*z; d) abs(x+y+z) – int(x)-int(y)-int(z); e) sqrt(x)+sqrt(y)+sqrt(z)+sqr(x)+sqr(y)+sqr(z); f) trunc(round(x)+round(y)+round(z)); g) round(x+4*(y-z)-67.5/(y+z)).

T4.6. Indicaţi definiţiile de constante corecte:

a) const consoana=’o’; b) Const nr=1.3456; c) const mesaj=’salutare’; d) Const fgfd=9; e) Const nr : single = 10.0; f) const ok : string = ‘excelent’.

T4.7. Să se specifice declaraţiile de variabile incorecte:

a) var l, k : single; o, p : string[5]; b) var h : integer = 3; c) var a, b, c : char; d) var x111, y111 : shortint;

T4.8. Se consideră condiţia logică: variabila a este un număr par. Care este modul de scriere al acesteia în limbajul Pascal? a) a mod 2 = 0; b) a div 2 = 0 c) a / 2 = 0; d) not (odd(a))

10


TEST 5

T5.1 Indicaţi identificatorii utilizator incorecţi: a) litera mica b) 1x c) x1

d) real e) variabila f) constanta g) sir h) a&b i) tip

T5.2 Care din următoarele definiţii de tipuri specifică numere naturale:

a) type naturale = 10..1000; b) type naturale = shortint; c) type naturale = 0..9; d) type.naturale = ’0’..’2000’; e) type naturale = word;

T5.3 Se consideră următoarea declaraţie: Var nr : 2000..4000; Alegeţi tipul corect al variabilei nr. a) word; b) subdomeniu; c) longint. T5.4 Indicaţi tipurile de date întregi:

a) integer; b) word; c) single; d) longint; e) shortint; f) byteint; g) double; h) char.

T5.5 Fie declaraţiile: Var a, b, c : char; Indicaţi expresiile corecte.

a) ord(a)+ord(b)+ord(c)

b) ord(succ(a))*ord(succ(b)) c) pred(a)+pred(b)+pred(c) d) ord(upcase(a))*ord(upcase(b))*ord(upcase(c)) e) (a + b) div 2 f) 255-ord(a)-ord(b)-ord(c) g) chr(255-ord(pred(c)))

T5.6 Indicaţi definiţiile de constante incorecte:

a) Const oras=’Craiova’; b) const numar : byte = 127.0; c) const integer = 1; d) const nr:=7.5; e) const tara=’romania’; f) const unu : shortint = -1;

T5.7 Să se specifice declaraţiile de variabile incorecte:

a) var a : integer, b : real; b) var 1x, 2x : double; c) var x : byte; x : char; d) var lit1, lit2 : char; e) var sir1, sir2, sir3 : string; s1, s2, s3 : char; f) var _suma, _produs : boolean;

T5.8. Se consideră următoarea expresie:

( )

k/6m+5*a+b

*y+x+c/2+ba

Care este modul de scriere al acesteia în limbajul Pascal?

a) (a/b+c/2)+sqrt(x+y)*((b+a)*5+m)/k/6 b) (a/(b+c/2))+sqrt(x+y)*((b+a)*5+m)/(k/6))

11


1.2.2. Citirea/scrierea datelor 1.2.2.1 Citirea datelor Citirea datelor se efectuează prin executarea procedurilor standard Read şi Readln. Apelul procedurii Read are forma: Read(v1, v2, … , vn) Apelul procedurii Readln are forma: Readln(v1, v2, … , vn)

Variabilele v1, v2, … , vn pot avea numai tipurile: Char, întreg sau interval de întregi, real sau string. Diagramele de sintaxă ale apelurilor acestor proceduri sunt:

12

apel

Read

Read ( Identificator(de variabilă)

)

,

Exemple: Se consideră următoarele declaraţii de variabile: Var a : Real; b : Integer; c, cc : char; d : Boolean; e : (roşu, galben, albastru); f : Byte; g : Word;

Apeluri ale procedurilor Read şi Readln Linii introduse de la tastatură Valorile variabilelor din lista de

argumente a procedurilor de citire Read(a,b,c) 40.0 –4DA<CR> a=40.0; b=-4; c=’D’ Readln(f,g,a) 200 20000<CR>40<CR> f=200; g=20000; a=40.0 Read(c,a,g,b) E-4 300 -99<CR> c=’E’; a=-4.0; g=300; b=-99 Read(a,b,c) 1E-4 75e<CR> a=0.0001; b=75; c=’e’ Read(c,cc,b) DA1000<CR> c=’D’; cc=’A’; b=1000

Apeluri ale procedurilor

Read şi Readln1

Linii introduse de la tastatură Observaţii

Read(f,a,c) 300 5 Da<CR> Valoarea maximă a unei variabile de tip Byte este 255. Readln(b,d) 200 true<CR> Datele de tip Boolean nu se pot citi. Read(g,a) -35 23.78<CR> Datele de tip Word sunt pozitive. Read(e,a,f) rosu 3.89 25<CR> Datele de tip enumerare nu se pot citi Read(a,b,c,f) -5-6.9c200<CR> Lipsesc separatorii (blanc, TAB sau Enter) între valorile numerice -5 şi 6.9.

1 Aceste apeluri sunt incorecte.

apel

Readln

) ( Identificator(de variabilă)

Readln

,


1.2.2.2 Scrierea datelor Scrierea (afişarea) datelor se efectuează cu procedurile standard Write şi Writeln. Apelul procedurii Write are forma: Write(e1, e2, … , en) Apelul procedurii Writeln are forma: Writeln(e1, e2, … , en)

Variabilele v1, v2, … , vn pot avea numai tipurile: Char, Boolean, întreg, real sau string. Diagrama de sintaxă a apelului procedurii Write este:

13

Diagrama de sintaxă a apelului procedurii Writeln este: Exemple:

Apeluri ale procedurilor Write şi Writeln Liniile afişate

Write(‘A’,#10,’A’) A A

Writeln(‘A’); Write(‘A’:4) A A

Write(‘AAAA’:3) AAAA Write(‘AAAA’:5) AAAA Writeln(‘A’,false); Write(‘A’,false:7)

Afalse A false

Apeluri ale procedurilor Write şi Writeln Liniile afişate

Write(‘A’,(4>2):7) A true Write(‘A’,30,20) A3020 Write(‘A’,30:3,20:3) A 30 20 Write(25.50) 2.5500000000E+01 Write(-25.50:7) -2.5E+02 Write(-25.50:7:2) -25.50 Write(25.50:5:1) 25.5 Write(25.50:5:0) 25

,

apel

Write

Write ( expresie )

,

: expresie: expresie

apel

Writeln

Writeln ( expresie ) : expresie : expresie


TEST 1

T1.1. Se consideră următoarele declaraţii: Var a : real; b : integer; c : char; Să se indice valoarea cu care se iniţializează variabila b în urma apelului: Read(a,b,c) ştiind că linia de comandă cuprinde

30 -40 %

a) -4 b) –40 c) 0 T 1.2. Se consideră următoarele declaraţii: Var m : shortint; n : single;

o : char; p : word; Să se indice valoarea cu care se iniţializează variabila o în urma apelului: Read(m,n,o,p) ştiind că linia de comandă cuprinde

100 30.5 2

a) ‘ ‘ b) ‘E’ c) E T 1.3. Se consideră următoarele declaraţii:

Var e : boolean; f, g : single;

h : byte; i : integer; j, k : char;

şi apeluri ale procedurii Read pentru care se indică linia de intrare corespunzătoare. Să se specifice apelurile incorecte.

a) read(e, i, k)

false 23 a b) read(f,h,g,k,j)

12.3 344 3.9yes

c) read(h,j,i)

100 200

T.1.4. Să se afişeze cuvintele ELENA CUZA sub forma:

E L E N A

C U Z A T 1.5. Să se iniţializeze variabilele reale a, b, c cu valori, apoi să se afişeze un tabel cu valorile pătratelor acestora.

14


TEST 2

T2.1. Se consideră următoarele declaraţii: Var s : string; t : shortint; u : longint; Să se indice valoarea cu care se iniţializează variabila s în urma apelului: Read(t,u,s) ştiind că linia de comandă cuprinde

100 300 100 eeeee

a) ‘eeeee’ b) ‘ eeeee’ c) ‘ 100 eeeee’ T 2.2. Se consideră următoarele declaraţii: Var i : integer; j : comp;

k : byte; m : char; Să se indice valoarea cu care se iniţializează variabila i în urma apelului: Read(j,i,k,m) ştiind că linia de comandă cuprinde

25 5000 45 a

a) 5000a b) 5000 c) 5 T 2.3. Se consideră următoarele declaraţii:

Var f, g : single; h : byte; i : integer; j, k : char;


a) read(f, i, k)

323 50000l b) read(h, g, j)

44 44.678 j

c) read(k,f,i)

kk 5 5

T.2.4. Să se afişeze cuvântul CUZA sub forma:

C U U Z Z A A Z Z U U C

T 2.5. Să se iniţializeze variabilele reale a, b, c cu valori, apoi să se afişeze un tabel cu valorile rădăcinilor pătrate ale acestora.

15


TEST 3

T3.1. Se consideră următoarele declaraţii: Var

i : char; j : byte; k : string;

Să se indice valoarea cu care se iniţializează variabila i în urma apelului: Read(j,i,k) ştiind că linia de comandă cuprinde

30 pascal

a) ‘p’ b) ‘ ’ c) p T 3.2 Să se specifice ce se afişează în urma execuţiei următorului apel al procedurii Write: Write(‘*****’:5,’$$$$$’:7) a) *****$$$$$ b) ***** $$$$$ c) *****$$$$$$$ T 3.3. Se consideră următoarele declaraţii: Var

f : string; g : integer; h : char; i : real;


a) read(g,i,f)

32000 9 00000aaaa b) read(h, g, i)

a 55 e-2

c) read(i,h,f)

22.77 zzzzzzzzz

T.3.4 Să se afişeze cuvântul ELENA sub forma:

E E L L E E N N A N N E E L L E E

T 3.5. Să se iniţializeze variabilele reale a, b, c cu valori, apoi să se afişeze valoarea true dacă acestea pot fi lungimi ale laturilor unui triunghi sau false, în caz contrar.

16


17

1.2. Introducere în limbajul Turbo Pascal. 1.2.1. Identificatori. Constante. Tipuri de date. Variabile. Expresii. Test 1. T1.1. a, e, f, h. T1.2. a, b, g. T1.3. a, d. T1.4. a, c, e, f. T1.5. b. T1.6. d. T1.7. a. T1.8. a, b, c, d. T1.9. b, d. Test 2. T2.1. c, f, h. T2.2. a, c, e, g. T2.3. b. T2.4. a, e. T2.5. d. T2.6. a, b, d. T2.7. a, c, e, f. T2.8. a, e, f. T2.9. c. T2.10. b. Test 3.

T3.1. a, d, e, f, h. T3.2. a, b. T3.3. c. T3.4. c. T3.5. a, b, c, d. T3.6. a, b, c, e, f. T3.7. a, b, c, e, f. T3.8. c. Test 4. T4.1. c. T4.2. a. T4.3. b. T4.4. b. T4.5. d, e, f, g. T4.6. a, b, c, d, e, f. T4.7. b. T4.8. a, d. Test 5. T5.1. a, b, d, h. T5.2. a, c, e. T5.3. b. T5.4. a, b, d, e. T5.5. a, b, d, f, g. T5.6. b, c, d. T5.7. a, b, c. T5.8. b.

1.2.2. Citirea/scrierea datelor Test 1. T1.1. b. T1.2. a. T.1.3.a (datele de tip boolean nu se pot citi), b (valoarea maximă a unei variabile de tip Byte este 255) T 1.4. writeln('E',#10,'L',#10,'E',#10,'N',#10,'A',#10,'C','U':2,'Z':2,'A':2)

RĂSPUNSURI

T 1.5. readln(a,b,c);

writeln('*********************'); write('*',a:8:2,'*':2,sqr(a):8:2,'*':2);writeln; write('*',b:8:2,'*':2,sqr(b):8:2,'*':2);writeln; write('*',c:8:2,'*':2,sqr(c):8:2,'*':2);writeln; write('*********************');


18

Test 2 T 2.1. c. T 2.2. b. T 2.3. a (valoarea maximă a unei variabile de tip Integer este 32767), c (f este de tip Single, nu Char) T 2.4.

writeln('C':4); writeln('U':3,'U':2); writeln('Z':2,'Z':4); writeln('A','A':6); writeln('Z':2,'Z':4); writeln('U':3,'U':2); writeln('C':4)

T 2.5. readln(a,b,c); writeln('*********************'); write('*',a:8:2,'*':2,sqrt(a):8:2,'*':2);writeln; write('*',b:8:2,'*':2,sqrt(b):8:2,'*':2);writeln; write('*',c:8:2,'*':2,sqrt(c):8:2,'*':2);writeln; write('*********************')

Test 3 T 3.1. b. T 3.2. b. T 3.3. b (înaintea lui e ar fi trebuit să fie una sau mai multe cifre) T 3.4.

writeln('E','E':8); writeln('L':2,'L':6); writeln('E':3,'E':4); writeln('N':4,'N':2); writeln('A':5); writeln('N':4,'N':2); writeln('E':3,'E':4);

writeln('L':2,'L':6); writeln('E','E':8);

T 3.5.

readln(a,b,c); write((a>0)and(b>0)and(c>0)and(a+b>c)and(a+c>b)and(b+c>a))

Culegere de probleme Structura liniară

Capitolul 2.

STRUCTURI DE CONTROL

2.1. Structura liniară.

Descrierea instrucţiunilor de atribuire şi compusă. Rezolvarea a 5 probleme ce utilizează aceste instrucţiuni. Se analizează problemele, se descriu algoritmii ce rezolvă problemele (schemă logică şi pseudocod ) şi se scriu programele Pascal ce transcriu algoritmii respectivi. Se propun spre rezolvare 3 teste ce cuprind exerciţii de tip grilă şi dezbaterea unor probleme. Se propune scrierea unor programe Pascal care să rezolve problemele date.

2.2. Structura alternativă.

Se descriu instrucţiunile if şi case. Se rezolvă 5 probleme ce utilizează fiecare această instrucţiune. Se analizează problemele, se descriu algoritmii de rezolvare (schemă logică şi pseudocod) şi se scriu programele Pascal ce transcriu algoritmii respectivi.Se propun spre rezolvare 3 teste ce cuprind exerciţii de tip grilă, dezbaterea unor probleme şi scrierea unui program Pascal pentru o problemă dată. Se propune scrierea unor programe Pascal care să rezolve problemele date.

19


2.1. STRUCTURA LINIARĂ Structura liniară cuprinde operaţii care se execută secvenţial. Această structură este generată de instrucţiunile de atribuire, compuse sau procedurale. În lucrarea de faţă, vom studia instrucţiunea de atribuire şi instrucţiunea compusă. 1. Instrucţiunea de atribuire

20

Instrucţiune compusă

begin Instrucţiune end

;

START

Citeşte v1, v2

m (v1+v2)/2

Scrie m

STOP

Diagrama de sintaxă a instrucţiunii de atribuire este următoarea:

Executarea acestei instrucţiuni constă în următoarele: - se evaluează expresia;

- variabila (funcţia) primeşte valoarea expresiei; dacă tipul expresiei nu coincide cu cel al variabilei (funcţiei), valoarea expresiei se converteşte înainte de atribuire în tipul identificatorului.

2. Instrucţiunea compusă

Instrucţiunea de atribuire

Identificator (de variabilă)

:= expresie

Identificator (de funcţie)

Diagrama de sintaxă a instrucţiunii compuse este următoarea:

Executarea instrucţiunii compuse constă în executarea instrucţiunilor cuprinse între delimitatorii begin şi end, în ordinea în care acestea apar.

Problema1. Un automobil a parcurs distanţa dintre două localităţi, la ducere cu km/h, iar la întoarcere cu km/h. Aflaţi media vitezelor. 1v 2v Rezolvarea problemei: Date de intrare: viteza la ducere – v1, viteza la întoarcere – v2. Date de ieşire: se afişează media vitezelor, m. Funcţia programului: se calculează media celor două viteze care este

media lor aritmetică, adică 2

2v1v.

Schema logică:

m


Algoritmul în pseudocod:

medie_viteze înseamnă: început scrie(‘Viteza la ducere’);

citeşte(v1); scrie(‘Viteza la intoarcere’);

citeşte(v2); m:=(v1+v2)/2; scrie(‘Media vitezelor este ’, m)

sfârşit.

Programul Pascal : program viteze; var v1, v2, m : real; begin write(‘Viteza la ducere este ’); readln(v1); write(‘Viteza la intoarcere’); readln(v2); m:=(v1+v2)/2; write(‘Viteza medie este ’,m:10:2) end.

Problema 2. Un dreptunghi are lăţimea de l1 metri şi lungimea de l2 metri. Aflaţi perimetrul pătratului care are aria egală cu a dreptunghiului. Rezolvarea problemei: Date de intrare: lăţimea l1 şi lungimea l2 a unui dreptunghi. Date de ieşire: se afişează perimetrul pătratului – p. Funcţia programului: se calculează perimetrul pătratului astfel: se determină aria pătratului care este egală cu aria dreptunghiului, adică produsul dintre l1 şi l2, se calculează lungimea laturii pătratului care este rădăcina pătrată a ariei pătratului, apoi se calculează perimetrul pătratului. Schema logică:

21

START

Citeşte l1, l2 aria l1*l2

l sqrt(aria)

STOP

p 4*l

Scrie p

Algoritmul în pseudocod: Perimetru_pătrat înseamnă: început scrie(‘Lăţime dreptunghi = ’); citeşte(l1); scrie(‘Lungime dreptunghi = ’); citeşte(l2); aria:=l1*l2; l:=sqrt(aria); p:=4*l; scrie(‘Perimetrul pătratului =’,p) sfârşit.

Programul Pascal: program perimetru; var l1, l2, aria : word; l, p : real; begin write(‘Lăţime dreptunghi = ’); read(l1); write(‘Lungime dreptunghi = ’); read(l2); aria:=l1*l2; l:=sqrt(aria); p:=4*l; write(‘Perimetrul patratului = ’,p:10:2) end.


Problema 3. Un obiect costă S lei. Calculaţi preţul obiectului după o scumpire cu p% şi apoi o reducere cu q%. Rezolvarea problemei: Date de intrare: preţul obiectului – S, procentul de scumpire – p, procentul de reducere – q. Date de ieşire: se afişează noul preţ al obiectului care este dat de valoarea variabilei pr. Funcţia programului: se calculează preţul obiectului după o scumpire cu p%, adică S+S*p/100; acest preţ fiind păstrat în variabila ps. După o reducere cu q%, adică ps-ps*q/100 care este păstrat în variabila pr, se obţine preţul obiectului. Schema logică

22

Algoritmul în pseudocod: preţ_obiect înseamnă: început citeşte(S,p,q); ps:=S+S*p/100; scrie(‘Preţ după scumpire = ’,ps); pr:=ps-ps*q/100; scrie(‘Preţ după reducere = ’,pr); sfârşit.

Programul Pascal: program obiect; var s, ps, pr, p, q : real; begin readln(s,p,q); ps:=s+s*p/100; write(‘Pret după scumpire = ’,ps:5:2); pr:=ps-ps*q/100; write(‘Pret după reducere = ’,pr:5:2); end.

START

Citeşte S,p,q

ps S+S*p/100

Scrie ps

pr ps-ps*q/100

Scrie pr

STOP

Problema 4. Media aritmetică a patru numere naturale este ma1. Găsiţi un număr care împreună cu cele patru numere să dea media aritmetică ma2. Rezolvarea problemei: Date de intrare: media aritmetică a patru numere naturale – ma1; media aritmetică a unui număr şi a celor patru numere la care ne-am referit anterior - ma2. Date de ieşire: se afişează numărul căutat, acesta fiind dat de valoarea variabilei nr. Funcţia programului: se determină numărul astfel: se calculează suma celor patru numere – s1=4*ma1, se calculează suma dintre cele patru numere şi numărul căutat – s2=5*ma2, apoi se obţine numărul prin calculul diferenţei dintre s2 şi s1, această diferenţă fiind atribuită variabilei nr.


Schema logică:

23

START

Citeşte ma1,ma2

s1 4*ma1

s2 5*ma2

nr s2–s1

Scrie nr

STOP

Algoritmul în pseudocod: număr înseamnă: început citeşte(ma1,ma2); s1:=4*ma1;

s2:=5*ma2; nr:=s2-s1;

scrie(‘Numărul este ’,nr) sfârşit.

Programul Pascal: program număr; var ma1, ma2, s1, s2, nr : real; begin readln(ma1,ma2); s1:=4*ma1; s2:=5*ma2; nr:=s2-s1; write(‘Numărul este ’,nr:5:0) end.

Problema 5. Să se calculeze media ponderată a numerelor reale a şi b cu ponderile p, respectiv q. Rezolvarea problemei: Date de intrare: numerele reale a şi b; numerele naturale p şi q care reprezintă ponderile lui a, respectiv b. Date de ieşire: se afişează valoarea variabilei mp care reprezintă media ponderată a numerelor considerate.

Funcţia programului: se calculează media ponderată a numerelor a şi b cu ponderile p, respectiv q : qp

q*bp*amp .

Schema logică: START

Citeşte a,b,p,q

mp (a*p+b*q)/(p+q)

Scrie mp STOP

Algoritmul în pseudocod: media_ponderată înseamnă: început scrie(‘a = ’); citeşte(a); scrie(‘Ponderea lui ’,a,’ = ‘);citeşte(p); scrie(‘b = ’); citeşte(b); scrie(‘Ponderea lui ’,b,’ = ‘);citeşte(q); mp:=(a*p+b*q)/(p+q); scrie(‘Media ponderată este ’,mp) sfârşit.

Programul Pascal: Program medie_ponderată; Var a, b, mp : real; p, q : word; begin write(‘a= ‘);readln(a); write(‘Ponderea lui ‘,a,’ = ’);readln(p); write(‘b= ‘);readln(b); write(‘Ponderea lui ‘,b,’ = ’);readln(q); mp:=(a*p+b*q)/(p+q); write(‘Media ponderată este ’,mp:5:2) end.


24

2.1.1. TESTE TEST 1 T1.1. Să se verifice corectitudinea sintactică pentru următoarele programe: a)

program test11; var a, b, s : byte; begin

readln(b,a); s=a+b;

write(s) end.

b) program test12; var x, y : real; begin

read(x,y); x:=x+y; y:=x-y; writeln(y,x);

end; T1.2. Dacă a şi b sunt variabile reale, iar x şi y sunt variabile întregi, identificaţi instrucţiunile de atribuire scrise corect: a) a:=a+4; b) x:=a*b; c) a*b:=x; d) a:=x+y; e) 27:=y; f) y:=(x+a/b)/2; g) b:=(a+x/y)/2; h) a:=x+y*b-a/3. T1.3. Se consideră definiţia şi declaraţiile: Const b=3; Var a : integer; i : word;

După efectuarea următoarelor operaţii alegeţi care este varianta corectă pentru valoarea variabilei a. i:=3; write(‘b = ‘,b); a:=i*b; write(‘a=’,a); Răspunsul este: I) 3 II) 6 III) 9. T1.4. Se consideră declaraţiile: var q,p : boolean; i,j : byte; După efectuarea următoarelor operaţii alegeţi care este varianta corectă pentru valoarea variabilei q. i:=7; j:=200; q:=true; p:=(i>6) and (j<=200); q:=not p; Răspunsul este: I) false II) true III) 207. T1.5. Introduceţi şi executaţi următorul program Pascal. Stabiliţi funcţia sa. program stabileşte1; var a, b, ma, mg : real; begin writeln('Stabileşte funcţia programului.'); write('a = ');read(a);write('b = ');read(b); ma:=(a+b)/2; mg:=sqrt(a*b); write(ma :7:2,’ ‘,mg:7:2) end.


25

TEST 2 T2.1. Să se verifice corectitudinea următoarelor programe: a)

program test21; const i=10; var a : word; begin read(a);

i:=a; write(i,a)

end. b)

const j=15; var a, b : double; begin read(a,b);

a=b+j; b:=a+j; writeln(a,b);

end T2.2. Dacă x,y şi z sunt variabile booleene, iar a, b şi c sunt variabile reale, identificaţi instrucţiunile de atribuire scrise corect: a) x:=y+z; b)a:=b+c; c) y:=x xor z; d) z:=x or y and (c=0); e) c:=(a*c+a/c)/2; f) y:=x and z and y; g) b:=(a+b)/2; h) c:=(a>0) and (b>0) and (c>0). T2.3. Se consideră următoarele declaraţii: Var n1, n2, n3 : integer; x, y, z : real;

După efectuarea următoarelor operaţii alegeţi care este varianta corectă pentru valoarea variabilei x. x:=7.0; n1:=5; n2:=0; n3:=10; y:=(n1+n2+n3)/3; z:=(x+y)/2; x:=y+z+n1+n2+n3; Răspunsul este: I) 16 II) 26.0 III) 7. T2.4. Se consideră definiţia şi declaraţiile: Const x=5; Var y : shortint; n : single; După efectuarea următoarelor operaţii alegeţi care este varianta corectă pentru valoarea variabilei n. y:=-100; n:=1.0; n:=y+n; y:=y+x; n:=y+n; Răspunsul este: I) –194.0 II) 1.0 III) 194.0. T2.5. Introduceţi şi executaţi următorul program Pascal. Stabiliţi funcţia sa. program stabileşte2; var x, y, z : shortint; begin writeln('Stabileşte funcţia programului.'); read(x,y); z:=x+y; writeln(z);z:=x-y; writeln(z); z:=x*y; writeln(z);z:=x div y; writeln(z); end.


26

TEST 3 T3.1. Să se verifice corectitudinea sintactică pentru următoarele programe: I)

var n1, n2, n3 : single; BEGIN readln(n1,n2);

n3=n1*n2; write(‘n3 = ‘,n3)

END.

II) const n=15; var a, b : shortint; c : real; begin readln(a,b);

c=(a+b)/n; write(‘Produsul = ’,c)

end. T3.2. Dacă n1 şi n2 sunt variabile de tip byte, iar c1 şi c2 sunt variabile de tip char, identificaţi instrucţiunile de atribuire scrise corect: a) c1:=chr(n1); b) chr(n2):=c2; c) c1:=chr(ord(c2)); d) c2:=chr(ord(c1)); e) n1:=ord(c2); f) n2:=ord(c1); g) n1:=n1 div n2; h) n1+n2:=ord(c1)+ord(c2). T3.3. Se consideră următoarele definiţii şi declaraţii: Const n1=1.0; n2=2.0; Var n : real; i : byte;

După efectuarea următoarelor operaţii alegeţi care este varianta corectă pentru valoarea variabilei n. i:=6; n:=(n1+n2)/i; i:=3; n:=(n1+n2)/i; Răspunsul este: I) 0.5 II) 1 III) 1.0. T3.4. Se consideră definiţiile şi declaraţiile: Const j=2; k=3; Var a, b, c : single; După efectuarea următoarelor operaţii alegeţi care este varianta corectă pentru valoarea variabilei c. a:=10.0; b:=20.0; c:=30.0 c:=(a+b)/j; c:=(a+b)/k; Răspunsul este: I) 30.0 II) 15.0 III) 10.0. T3.5. Introduceţi şi executaţi următorul program Pascal. Stabiliţi funcţia sa. program stabileste3; const n=2; var m, n1, n2, n3 : double; begin writeln('Stabileste functia programului.'); readln(n1,n2,n3); m:=(n1+n2+n3)/(n+1); write(m:5:2) end.


2.1.2. Probleme propuse

27

1. Se citesc numerele naturale b şi f care reprezintă numărul de băieţi

respectiv de fete dintr-o clasă. Să se afişeze raportul dintre:a) numărul băieţilor şi numărul fetelor; b) numărul fetelor şi numărul băieţilor.

2. Se citesc numerele naturale b şi f care reprezintă numărul de băieţi

respectiv de fete dintr-o clasă. Să se afişeze raportul procentual dintre:a) numărul băieţilor şi numărul elevilor; b) numărul fetelor şi numărul elevilor.

3. Alexandru a economisit S lei şi îi depozitează într-o bancă cu o

dobândă de p% pe an, pentru un termen de l luni. Să se afişeze dobânda obţinută după l luni. S, p şi l sunt numere naturale care se citesc de la tastatură.

4. Un teren a fost cultivat astfel: p1% cu porumb, p2% cu grâu, p3% cu

orz şi restul de q ha cu floarea-soarelui. Să se afişeze aria întregii suprafeţe, precum şi ariile suprafeţelor cultivate cu porumb, grâu,respectiv orz.Numerele pozitive p1, p2, p3 şi q se citesc de la tastatură.

5. Se citesc numerele pozitive a, b şi c. Un bazin paralelipipedic are

lungimea a m, lăţimea b m şi adâncimea c m. Să se afişeze volumul bazinului.

6. O persoană doarme, în medie, 8 ore pe zi. Să se afişeze câte ore va

consacra somnului o persoană care trăieşte N ani. N este un număr natural care se citeşte de la tastatură.

7. Se citesc numerele naturale l1, l2 şi x. O curte în formă de

dreptunghi, cu dimensiunile de l1 m şi l2 m, trebuie asfaltată cu un strat gros de x cm. Să se afişeze aria suprafeţei asfaltate şi volumul asfaltului.

8. Se citesc numerele naturale n1, n2, n3 şi t care reprezintă notele

luate de Bianca pe semestrul I la matematică - la oral, respectiv la teză. Să se afişeze media semestrială cu două zecimale şi apoi rotunjirea la un număr întreg a acestei medii.

9. Se citesc numerele întregi pozitive a şi b. Să se rezolve ecuaţia cu o

necunoscută ax+b=0. 10. Se citeşte numărul natural l care reprezintă latura unui cub. Să se

afişeze volumul cubului, suma lungimilor muchiilor şi suma ariilor feţelor.

Rezolvaţi problemele utilizând limbajul de programare Pascal


28

RĂSPUNSURI Structura liniară. Test 1. T1.1 a) Instrucţiunea de atribuire s=a+b este incorectă. Forma corectă este s:=a+b. b) Orice program Pascal se termină cu caracterul ‘.’. Deci, în loc de ‘;’ avem ‘.’. T1.2 a),d),g),h). T1.3 III. T1.4 I. T1.5 Acest program Pascal afişează media aritmetică, respectiv media geometrică a două numere reale, a şi b. Test 2. T2.1 a) Instrucţiunea de atribuire i:=a este incorectă deoarece în stânga operatorului ‘:=’ avem un identificator de constantă. b) Instrucţiunea de atribuire a=b+j este incorectă. Forma corectă este a:=b+j. Orice program Pascal se termină cu ‘.’. Deci după cuvântul cheie ‘end’ se pune caracterul ‘.’. T2.2 b), c), d), e), f), g). T2.3 II. T2.4 I. T2.5 Programul Pascal determină suma, diferenţa, produsul, respectiv câtul a două numere întregi. Test 3. T3.1 I) Instrucţiunea de atribuire n3=n1*n2 este incorectă. Forma corectă este n3:=n1*n2. II) Instrucţiunea de atribuire c=(a+b)/n este incorectă. Forma corectă este c:=(a+b)/n. T3.2 a), c), d), e), f), g). T3.3 III. T3.4 III. T3.5 Programul Pascal determină media aritmetică a trei numere reale. Probleme propuse 1. program clasa; var

f, b : word; r1, r2 : real;

begin write(‘Nr. fetelor = ’); read(f); write(‘Nr. baietilor = ’); read(b); r1:=f/b; write(‘Raportul dintre nr. fetelor si nr. baietilor = ’,r1); r2:=b/f; write(‘Raportul dintre nr. baietilor si nr. fetelor = ’,r2) end.

2. program clasa; var

f, b : word; r1, r2 : real; begin write(‘Nr. fetelor = ’); read(f); write(‘Nr. baietilor = ’); read(b); r1:=b*100/(f+b); write(‘Raportul procentual dintre nr. baietilor si nr. elevilor = ’,r1:5:2); r2:=f*100/(f+b); write(‘Raportul procentual dintre nr. fetelor si nr. elevilor = ’,r2:5:2);


29

end. 3. program dobanda; var

p, S, l : word; x, y : real; begin write(‘Suma = ’); readln(S); write(‘Dobanda = ’); readln(p); write(‘Nr. luni = ’); readln(l); x:=S*p/100; write(‘Dobanda pe un an = ‘,x:5:2) y:=x*l/12; write(‘Dobanda pe ’,l,’ luni = ‘,y:5:2) end. 4. program teren; var p1, p2, p3, q, t, p, g, o : real; begin write(‘Teren cu porumb (%)=’); readln(p1); write(‘Teren cu grau (%)=’); readln(p2); write(‘Teren cu orz (%)=’); readln(p3); write(‘Teren cu floarea-soarelui (ha)=’); readln(q); t:=q*100/(100-p1-p2-p3); write(‘Aria terenului (ha) =’,t:5:2); p:=t*p1/100; write(‘Teren cu porumb (ha)=’,p:5:2); g:=t*p2/100; write(‘Teren cu grau (ha)=’,g:5:2); o:=t*p3/100; write(‘Teren cu orz (ha)=’,o:5:2); end. 5. program bazin; var a, b, c, vol : real; begin

write(‘Lungime bazin = ’); readln(a); write(‘Latime bazin = ’); readln(b); write(‘Adancime bazin = ’); readln(c); vol:=a*b*c; write(‘Volum bazin = ’,vol) end. 6. program ore_somn; var N : byte; somn : longint; begin write(‘Varsta persoana = ’); readln(N); somn:=8*365*N; write(‘Persoana doarme ’,somn,’ ore.’) end. 7. program curte; var

l1, l2, x, aria : word; vol : real; begin writeln(‘Dimensiunile curţii:’);

write(‘l1 (m) = ’); readln(l1); write(‘l2 (m) = ’); readln(l2); write(‘Grosimea asfaltului (cm) = ’); readln(x) aria:=l1*l2; writeln(‘Aria suprafeţei asfaltate = ’,aria); vol:=aria*x*0.01; write(‘Volumul asfaltului = ’,vol:5:2,’ m’);

end. 8. program medie; var


30

n1, n2, n3, t, med2 : byte; med1 : real; begin writeln(‘Notele la oral’); write(‘Nota 1 = ’); readln(n1); write(‘Nota 2 = ’); readln(n2); write(‘Nota 3 = ’); readln(n3); write(‘Nota la teza = ’); readln(t); med1:=(n1+n2+n3)/3; med1:=(3*med1+t)/4; writeln(‘Media semestrială (cu 2 zecimale)= ’,med1:5:2); med2:=round(med1); write(‘Media semestrială (rotunjita) = ’,med2); end. 9. program ecuaţie; var

a, b : word; x : real; begin write(‘a = ’);readln(a); write(‘b = ’);readln(b); x:=-b/a; write(‘Solutia = ’,x:5:2) end. 10. program cub; var l, sm, sa, vol : word; begin write(‘Latura cub = ’); readln(l); vol:=l*l*l; writeln(‘Volum cub = ’,vol); sm:=12*l; writeln(‘Suma muchii = ’,sm);

sa:=6*l*l; write(‘Suma ariilor feţelor = ’,sa) end.

Culegere de probleme Structura alternativă

2.2. STRUCTURA ALTERNATIVĂ 2.2.1. Instrucţiunea IF Instrucţiunea IF are două forme. Forma 1:

31

IF condiţie THEN

instrucţiune1 ELSE

Instrucţiune2

Forma 2:

IF condiţie THEN instrucţiune

Condiţie este o expresie booleană, instrucţiune1, instrucţiune2 şi instrucţiune sunt instrucţiuni Pascal. Executarea instrucţiunii IF se realizează astfel: - se evaluează condiţia; - dacă valoarea sa este true se execută instrucţiune1şi se trece la instrucţiunea următoare, altfel se execută instrucţiune2,

dacă folosim forma 1 a instrucţiunii, iar dacă folosim forma 2 – nu se execută nimic. Diagrama de sintaxă a instrucţiunii IF este următoarea:

Instrucţiunea IF

Problema 1. Se dă un număr natural n. Să se determine dacă acest număr este ori par, ori impar. Rezolvarea problemei: Date de intrare: numărul natural n. Date de ieşire: se afişează pe ecran unul din următoarele mesaje:

- ’Număr par’, în cazul în care n este număr par; - ’Număr impar’, în cazul în care n este număr impar;

Expresie (booleană) Instrucţiune 1IF THEN ELSE Instrucţiune 2


Funcţia programului: Se determină dacă un număr este par sau impar. Pentru aceasta se verifică valoarea de adevăr a condiţiei n mod 2 = 0 (restul împărţirii lui n la 2 este egal cu zero). În cazul în care este adevărată această condiţie înseamnă că numărul dat este par, în caz contrar, adică condiţia este falsă – numărul dat este impar. Schema logică:

32

START

n mod 2 = 0

Citeşte n DA NU

Scrie ‘Număr par’ Scrie ‘Număr impar’ STOP


Par_impar înseamnă: început

scrie(‘n = ‘);citeşte(n); dacă n mod 2 = 0 atunci scrie(‘Număr par’) altfel scrie(‘Număr impar’)

sfârşit.

Programul Pascal:

program par_impar; var n : integer; begin write(‘n = ‘); readLn(n); if n mod 2 = 0 then write(‘Numar par’) else write(‘Numar impar’) end.

Problema 2. Se citesc de la tastatură trei numere. Să se afişeze cel mai mare număr citit. Rezolvarea problemei: Date de intrare: cele trei numere care sunt date de variabilele a, b şi c. Date de ieşire: cel mai mare număr citit (care este dat de variabila max dacă se alege soluţia I). Funcţia programului: Soluţia I: Se determină cel mai mare număr citit astfel:

- se consideră că cel mai mare număr citit este a. Deci variabila max va primi valoarea variabilei a; - se compară max cu b. În cazul în care valoarea lui b este mai mare decât valoarea lui max, atunci max va

primi valoarea lui b;


- se compară max cu c. În cazul în care valoarea lui c este mai mare decât valoarea lui max, atunci max va primi valoarea lui c.

Schema logică:

33

Algoritmul în pseudocod: START

Maxim1 înseamnă:

Citeşte a,b,c început scrie(‘a = ‘); citeşte(a); scrie(‘b = ‘); citeşte(b);

max a scrie(‘c = ‘); citeşte(c); max:=a;

dacă b>max atunci max:=b; dacă c>max atunci max:=c;

scrie(‘Maximul este ’,max) sfârşit.

Programul Pascal:

program maxim1; var a,b,c,max : integer;

begin write('a = ');read(a); write('b = ');read(b); write('c = ');read(c); max:=a; if b>max then max:=b; if c>max then max:=c; write('Maximul este ',max) end.

Scrie max

b>maxDA

max b

c>maxDA

max c

STOP

NU

NU


Soluţia II: Se determină cel mai mare număr astfel: Se compară a şi b. Avem două situaţii:

- Cel mai mare număr este a şi se compară a şi c. Dacă maximul este a, se afişează acesta şi algoritmul se încheie. În caz contrar, se compară b şi c. Dacă b<c atunci maximul este c, se afişează acesta şi algoritmul se încheie. În caz contrar, maximul este b, se afişează acesta şi algoritmul se încheie.

- Cel mai mare număr este b şi se compară b şi c. Dacă b>c atunci maximul este b, se afişează şi algoritmul se încheie. În caz contrar, se compară a şi c. Dacă c< a atunci maximul este c, se afişează şi algoritmul se încheie. În caz contrar, maximul este a, se afişează şi algoritmul se încheie.

Schema logică:

STARTAlgoritmul în pseudocod:

Citeşte a,b,c maxim2 înseamnă: început scrie(‘a = ‘);citeşte(a);

34

a>b

DA NU scrie(‘b = ‘);citeşte(b); scrie(‘c = ‘);citeşte(c);

NU

b>c

DA

Scrie b

NU

c>a DA NU

Scrie c Scrie a

a>c

DA

Scrie a

dacă a>b atunci dacă a>c atunci scrie(a) altfel dacă b<c atunci scrie(c)

b<cDA NU altfel scrie(b)

altfel

Scrie cScrie b

STOP

dacă b>c atunci scrie(b) altfel dacă c>a atunci scrie(c) altfel scrie(a) sfârşit.


Programul Pascal:

35

program maxim2; var a,b,c,max : integer; begin write('a = ');read(a); write('b = ');read(b); write('c = ');read(c); if a>b then

if a>c then write(a) else if b<c then write(c) else write(b) else if b>c then write(b) else if c>a then write(c) else write(a) end.

Problema 3. Se dau trei numere a, b, c. Să se testeze dacă ele pot fi lungimile laturilor unui triunghi. Rezolvarea problemei: Date de intrare: numerele reale a, b, c. Date de ieşire: se afişează unul dintre următoarele mesaje: ‘Numerele date pot fi lungimi ale laturilor unui triunghi’, ‘Numerele date nu pot fi lungimi ale laturilor unui triunghi’ Funcţia programului: se determină dacă numerele date pot fi lungimi ale laturilor unui triunghi. Pentru aceasta, numerele trebuie să fie pozitive şi suma oricăror două numere să fie mai mare decât celălalt număr. Schema logică:


Triunghi înseamnă: început

citeşte(a,b,c); dacă (a>0) ŞI (b>0) ŞI (c>0) ŞI (a+b>c) ŞI (a+c>b) ŞI

(b+c>a) atunci scrie(‘Numerele date pot fi lungimi ale laturilor

unui triunghi’) altfel scrie(‘Numerele date nu pot fi lungimi ale

laturilor unui triunghi’) sfârşit.

START

(a>0) ŞI (b>0) ŞI (c>0) ŞI (a+b>c) ŞI (a+c>b) ŞI (b+c>a)

DA NU

Scrie ‘Nr date nu pot fi lungimi ale lat. unui triunghi’

Scrie ‘Nr. date pot fi lungimiale lat. unui triunghi’

Citeşte a,b,c

STOP


Programul Pascal:

program triunghi; var a, b, c : integer; begin readln(a,b,c);

if (a>0) and (b>0) and (c>0) and (a+b>c) and (a+c>b) and (b+c>a) then write(‘Numerele date pot fi lungimi ale laturilor unui triunghi’) else write(‘Numerele date nu pot fi lungimi ale laturilor

unui triunghi’) end.

Problema 4. Se citesc de la tastatură numerele abc şi xyz cifră cu cifră. Să se verifice care dintre ele este mai mic.

36

STARTRezolvarea problemei:Date de intrare: două numere pentru care se dau cifrele lor. Astfel, primul număr are cifrele date de variabilele a,b şi c, iar cel de-al doilea număr are cifrele date de variabilele x, y şi z.

Citeşte a,b,c,x,y,z

a<xDA NU

Scrie a,b,c

Date de ieşire: se afişează pe ecran cel mai mic număr dintre cele două numere sau mesajul ‘Sunt egale.’, dacă cele două numere sunt egale.

b>y DA NU

Scrie x,y,z

b<yDA NU

Scrie a,b,c

a>xDA NU

Scrie x,y,z

c<z DA NU

Scrie a,b,cc>z DA NU

Scrie x,y,zScrie ‘Sunt egale’

Funcţia programului: se verifică care dintre cele două numere este mai mic. Pentru aceasta se compară cifrele sutelor, cifrele zecilor, respectiv cifrele unităţilor celor două numere. Dacă din compararea cifrelor sutelor celor două numere rezultă că una este mai mică atunci acest număr este mai mic, se afişează pe ecran şi algoritmul se încheie. În cazul în care obţinem că cele două cifre sunt egale, se trece la compararea cifrelor zecilor celor două numere. Dacă rezultă că una este mai mică atunci numărul corespunzător este mai mic, se afişează pe ecran şi algoritmul se încheie. În cazul în care obţinem că cele două cifre sunt egale, se trece la compararea cifrelor unităţilor. Dacă rezultă că una dintre cifre este mai mică atunci numărul corespunzător este mai mic, se afişează pe ecran şi algoritmul se încheie. În cazul în care obţinem că cele două cifre sunt egale, înseamnă că cele două numere sunt egale, se afişează mesajul ‘Sunt egale.’ şi algoritmul se încheie.

STOP


37

Algoritmul în pseudocod: Numere înseamnă: Început scrie('a = '); citeşte(a); scrie('b = '); citeşte(b); scrie('c = '); citeşte(c); scrie('x = '); citeşte(x); scrie('y = '); citeşte(y); scrie('z = '); citeşte(z); dacă a<x atunci scrie('abc = ',a,b,c) altfel dacă a>x atunci scrie('xyz = ',x,y,z)

altfel dacă b<y atunci scrie('abc = ',a,b,c) altfel dacă b>y atunci scrie('xyz = ',x,y,z)

altfel dacă c<z atunci scrie('abc=',a,b,c) altfel dacă c>z atunci scrie('xyz =

',x,y,z) altfel scrie('Sunt egale.')

sfârşit.

Programul Pascal:

program numere; var a,b,c,x,y,z : integer; begin write('a = ');read(a); write('b = ');read(b); write('c = ');read(c); write('x = ');read(x); write('y = ');read(y); write('z = ');read(z); if a<x then write('abc = ',a,b,c) else if a>x then write('xyz = ',x,y,z) else

if b<y then write('abc = ',a,b,c) else

if b>y then write('xyz = ',x,y,z) else

if c<z then write('abc = ',a,b,c) else if c>z then write('xyz = ',x,y,z) else write('Sunt egale.') end.

Problema 5. Un copil merge pe o şosea şi trece prin dreptul unui marcaj A pe care există o specificaţie în kilometri, metri, centimetri şi milimetri, apoi merge o distanţă d dată în milimetri. Să se determine punctul B în care ajunge după parcurgerea distanţei d. Punctul B se va specifica prin kilometri, metri, centimetri şi milimetri. De exemplu dacă punctul A este dat de: 36km, 999m, 99 cm, 9mm şi d=2001mm, atunci B este dat de 37km, 2m, 0cm,0mm. Rezolvarea problemei: Date de intrare:Specificaţia în kilometri, metri, centimetri şi milimetri a unui marcaj A dată de variabilele akm, am, acm, respectiv amm. Distanţa parcursă (în milimetri) dată prin variabila d. Date de ieşire: specificaţia punctului B în care se ajunge după parcurgerea distanţei d plecând din punctul A. Aceasta este dată de către valorile variabilelor bkm, bm, bcm, bmm care se afişează pe ecran. Funcţia programului: Se determină specificaţia punctului B în care se ajunge parcurgând distanţa d din punctul A.


Schema logică: 1START

38

Citeşte akm,am,acm,amm,d

bkm akm

bm am

bcm acm

bmm amm

d>0 DA

d div 10 < 1

DA

bmm bmm+d bmm bmm+d mod 10

d d div 10

NU

NU

1

bmm div 10 <> 0

bcm bcm+bmm div 10

bmm bmm mod 10

DA NU

NU d>0

DA

d div 10 < 10

DA

bcm bcm+d mod 10 bcm bcm+d

d d div 10

NU

NUbcm div 100 <> 0

DA

bm bm+bcm div 100

bcm bcm mod 100

2


39

2 3

d d div 1000

NU

d>0 DA

d div 10<100

Scrie bkm,bm,bcm,bmm

DA

bm bm+d bm bm+d mod 10

NU STOP


Sosea înseamnă:

început citeşte(akm, am, acm, amm); citeşte(d); bkm:=akm; bm:=am; bcm:=acm; bmm:=amm;

dacă d>0 atunci început NU

bm div 1000 <> 0DA

dacă d div 10 < 1 atunci

bkm bkm+bm div 1000

bm bm mod 1000

bmm:=bmm+d altfel bmm:=bmm + d mod 10; d:=d div 10 sfârşit; dacă bmm div 10 <> 0 atunci

început bcm:=bcm + bmm div 10; NU

d>0 DA

bmm:=bmm mod 10

d div 10<100

DA

bkm bkm+d bkm bkm+d mod 10

sfârşit; dacă d>0 atunci

NU început dacă (d div 10 < 10) atunci bcm:=bcm+d

altfel bcm:=bcm + d mod 10; d:=d div 100; sfârşit; dacă bcm div 100 <> 0 atunci

început 3 bm:=bm + bcm div 100;

bcm:=bcm mod 100


40

sfârşit; dacă (d>0) atunci început dacă d div 10 < 100 atunci bm:=bm+d altfel bm:=bm + d mod 10; d:=d div 1000; sfârşit; dacă bm div 1000 <> 0 atunci început bkm:=bkm + bm div 1000; bm:=bm mod 1000 sfârşit; dacă d > 0 atunci dacă d div 10 < 100 atunci bkm:=bkm+d altfel bkm:=bkm + d mod 10; scrie(bkm,'km ', bm,'m ', bcm,'cm ', bmm,'mm'); sfârşit. Programul Pascal: program sosea; var akm,am,acm,amm,d,bkm,bm,bcm,bmm : longint; begin readln(akm);readln(am);readln(acm);readln(amm);readln(d); bkm:=akm; bm:=am; bcm:=acm; bmm:=amm; if d>0 then begin if d div 10 < 1 then bmm:=bmm+d else bmm:=bmm + d mod 10; d:=d div 10 end; if bmm div 10 <> 0 then

begin bcm:=bcm + bmm div 10; bmm:=bmm mod 10 end; if d>0 then begin if (d div 10 < 10) then bcm:=bcm+d else bcm:=bcm + d mod 10; d:=d div 100; end; if bcm div 100 <> 0 then begin bm:=bm + bcm div 100; bcm:=bcm mod 100 end; if (d>0) then begin if d div 10 < 100 then bm:=bm+d else bm:=bm + d mod 10; d:=d div 1000; end; if bm div 1000 <> 0 then begin bkm:=bkm + bm div 1000; bm:=bm mod 1000 end; if d > 0 then if d div 10 < 100 then bkm:=bkm+d else bkm:=bkm + d mod 10; write(bkm,'km ');write(bm,'m ');write(bcm,'cm ');write(bmm,'mm'); end.


41

2.2.2. TESTE TEST 1 T1.1. Ce determină executarea secvenţei de program?

readln(a,b,c); if a<=b then b:=b+c;

a:=a+c else c:=a+b;

T1.2. Se consideră declaraţiile: Var a, b, c : integer; x, y, z : boolean;

Indicaţi instrucţiunile if corect scrise.

a) if a+b>c then write(c,’este mai mic decât suma numerelor ‘,a,’ şi ‘,b);

b) if a>0 and c<1 then writeln(a*c); else write(a+c); c) if x and (b>0) then write(b); T1.3. Se consideră declaraţiile: Var a, b, c : integer;

După efectuarea următoarelor operaţii alegeţi care este varianta corectă pentru valoarea variabilei a.

a) a:=5; c:=3; if a mod 3 > 1 then b:=a+2; a:=b+c;

Răspunsul este: I) 7 II) 5 III) 10. b) b:=1; c:=7; if c < 7 then a:=1 else b:=c+1; a:=b-1;

Răspunsul este: I) 1 II) 7 III) 0. c) c:=4; a:=4; if a+c>0 then a:=a-2 else b:=a-2; a:=a+2;

Răspunsul este: I) 4 II) 2 III) 6.

T1.4. Introduceţi şi executaţi următorul program Pascal.

Stabiliţi funcţia sa.

program stabileşte1; var d, n : byte; begin writeln('Stabileste funcţia programului.'); write('n = ');read(n); write('d = ');read(d); if n mod d = 0 then writeln('Da.') else writeln('Nu.') end.

T1.5. Scrieţi programul Pascal pentru rezolvarea următoarei

probleme. Se citeşte o literă şi se stabileşte dacă aceasta este vocală.


TEST 2. T2.1. Ce determină executarea secvenţei de program?

read(y,x0,x1,eps); if (y>=x0) and (y<=x1) then y:=(x0+x1)/2; else x0:=x0+eps; x1:=x1+eps;

T2.2. Se consideră declaraţiile: Var a0, a1, x : word; s1, s2 : string[5];


a) if a0+a1> x then write(a0+a1); b) if a0<x and a1>x then writeln(x); c) if s1 and (a0>0) then writeln(s2); else writeln(s1); T2.3. Se consideră declaraţiile: Var x, y, z : byte;

După efectuarea următoarelor operaţii alegeţi care este varianta corectă pentru valoarea variabilei x.

a) x:=7; z:=3; if x mod 3 < 2 then y:=z+2; x:=y+z; Răspunsul este: I) 7 II) 2 III) 8.

b) y:=0; z:=2; if z < 7 then x:=1 else z:=y+1; x:=z-1;

Răspunsul este: I) 2 II) 1 III) 0. c) x:=4; y:=8;

if x+y<=12 then x:=x-2 else x:=x+2; x:=y+2;

Răspunsul este: I) 10 II) 2 III) 6. T2.4. Introduceţi şi executaţi următorul program Pascal.

Stabiliţi funcţia sa. program stabileşte2; var x : real; begin writeln(‘Stabileste functia programului.’); write(‘x = ‘);readln(x); if x=0 then write(‘zero’) else if x>0 then write(‘pozitiv’) else write(‘negativ’); end. T2.5. Scrieţi programul Pascal pentru rezolvarea următoarei

probleme. Fie n= xzy un număr natural de trei cifre. Cunoscând cifrele x, y şi z, să se testeze dacă n este divizibil cu numărul 3

42


43

TEST 3. T3.1. Ce determină executarea secvenţei de program?

read(b); if b:=0 then write(‘Numar nul.’) else write(‘Numar nenul.’);

T3.2. Se consideră declaraţia: Var a : word;


a) if a > 0 then write(‘Număr negativ’); b) if a:=0 then writeln(‘Număr nenul’);

c) if a<0 then write(‘Nr negativ’); else write(‘Nr pozitiv’); T3.3. Se consideră declaraţiile: Var s1, s2, s3 : integer;

După efectuarea următoarelor operaţii alegeţi care este varianta corectă pentru valoarea variabilei s1.

a) s1:=75; if s1 div 4 < 2 then s2:=s1+2 else s2:=s1+4;

s1:=s2+2; Răspunsul este: I) 81 II) 79 III) 77.

b) s2:=10; s3:=12; if s2 < 7 then s1:=1 else s3:=s3+1; s1:=s3;

Răspunsul este: I) 1 II) 13 III) 12. c) s1:=20; s3:=40;

if s1 div s3 > 0 then s2:=0 else s2:=1; s1:=s2;

Răspunsul este: I) 20 II) 0 III) 1. T3.4. Introduceţi şi executaţi următorul program Pascal.

Stabiliţi funcţia sa. program stabileşte3; var a, b, c : word; begin writeln(‘Stabileşte funcţia programului.’); readln(a,b,c);

if ((a*a+b*b=c*c) or (b*b+c*c=a*a) or (c*c+a*a=b*b)) then write(a,b,c,‘ sunt pitagorice.’) else write(a,b,c,‘ nu sunt pitagorice.’) end.


probleme. Se dau trei numere a,b şi c. Să se testeze dacă acestea formează un triunghi isoscel.


2.2.3. PROBLEME PROPUSE

44

1. Se citeşte un număr n. Să se verif ice dacă numărul este pozitiv sau negativ.

2. Se citesc numerele nenule n şi m. Dacă cele două numere sunt pozitive atunci se calculează suma acestora, în caz contrar – se calculează produsul acestora.

3. Se citesc numerele x şi y. Dacă f racţ ia x/y este subunitară atunci să se calculeze raportul dintre y şi x.

4. Se citesc numerele a şi b. Dacă cele două numere sunt diferite atunci se calculează diferenţa acestora. Observaţ ie: se va scădea numărul mai mic din numărul mai mare.

5. Se citesc numerele x, y, z. Să se af işeze cel mai mic număr citit.

6. Se citesc numerele a, b, c. Să se af işeze aceste numere în ordine crescătoare.

7. Se citesc numerele a, b, c. Să se af işeze aceste numere în ordine descrescătoare.

8. Se citesc numerele întregi x şi y. Să se l lui y. verif ice dacă x este divizor a

9. Se citesc numerele întregi n şi m. Să se verif ice dacă n este divizibil cu m.

10. Să se verif ice dacă numărul întreg a, citit de la tastatură, este divizibil cu 3.

11. Să se verif ice dacă numărul întreg n, citit de la tastatură, este divizibil cu 4.

12. Se citeşte vârsta unei persoane (exprimată în ani) şi se af işează dacă este majoră sau minoră.

13. Se citeşte o l iteră şi se af işează un mesaj dacă ea este consoană sau vocală.

14.Fie n= xzy un număr natural de trei cif re. Cunoscând numai cif rele x, y şi z, să se testeze dacă n este divizibil cu numărul 9.

15. Fie n= vxyz un număr natural de patru cif re. Cunoscând numai cif rele v, x, y şi z, să se testeze dacă n este divizibil cu numărul 7.

Rezolvaţi problemele utilizând limbajul de programare Pascal.


2.2.4. Instrucţiunea CASE. Instrucţiunea case transcrie o structură condiţională mai generală decât structura IF-THEN-ELSE, care permite alegerea

nei alternative din mai multe posibile. Sintaxa acestei instrucţiuni este următoarea: u Instrucţiunea

CASE

45

case Expresie (ordinală)

Alternative(case) of end instrucţiune else

alternative case

Expresia ordinală din diagramă se numeşte selector, iar constantele, al căror tip trebuie să fie identic cu al selectorului, se numesc constante case. Construcţia constanta1 .. constanta2 dintr-o alternativă case semnifică toate valorile aparţinând intervalului definit de cele două constante.

case se realizează astfel: Executarea instrucţiunii I) Se evaluează selectorul; II) Se caută alternativa case care cuprinde valoarea selectorului. Dacă se găseşte o asemenea alternativă, se execută

instrucţiunea care o urmează. În caz contrar, se execută instrucţiunea care urmează cuvântului cheie else, în lipsa acestuia nu se execută nimic.

roblema 1. Se citeşte numărul de ordine al unei zile a săptămânii şi se afişează denumirea sa. P

Rezolvarea problemei: Date de intrare: numărul de ordine al unei zile nr. Date de ieşire: Se afişează denumirea zilei ce are numărul de ordine nr.

constanta1 Instrucţiune : .. Constanta2

;,


46

uncţia programului: se determină denumirea unei zile dacă se cunoaşte numărul său de ordine. F

lgoritm în pseudocod: A

mnă: Zi înseaînceput citeşte(nr); în caz că nr este 1 : scrie(‘LUNI’); 2 : scrie(‘MARŢI’);

; 3 : scrie(‘MIERCURI’) 4 : scrie(‘JOI’); 5 : scrie(‘VINERI’); 6 : scrie(‘SÂMBĂTĂ’); 7 : scrie(‘DUMUNICĂ’);

l scrie(‘Nr. citit necorespunzator.’); altfegata

fârşit s

Programul Pascal: program zi;

: 1..7; var nrbegin

e ordine al zilei ');readln(nr); write('Nr. d case nr of 1 : writeln('LUNI'); 2 : writeln('MARTI');

CURI'); 3 : writeln('MIER 4 : writeln('JOI'); 5 : writeln('VINERI'); 6 : writeln('SAMBATA'); 7 : writeln('DUMINICA');

lse writeln('Nr. citit necorespunzator.') e end

end.

roblema 2. Se citeşte un număr şi se determină dacă acesta este cifră zecimală. P

Rezolvarea problemei: Date de intrare: numărul nr. Date de ieşire: se afişează mesajul 'CIFRA ZECIMALA' dacă numărul citit este cifră zecimală, în caz contrar, afişându-se mesajul Nr. citit nu este cifra zecimala.'.

uncţia programului: Se determină dacă numărul citit este cifră zecimală. F

lgoritmul în pseudocod: A

imală înseamnă: Cifra_zec Început

măr ’);citeşte(nr); scrie(‘Citiţi un nu în caz că nr este 0..9 : scrie(‘CIFRĂ ZECIMALĂ);

altfel scrie('Nr. citit nu este cifra zecimala.'); ta

Sfârşit.

_zecimala;

ga Programul Pascal:

m cifraprogra


47

e writeln('Nr. citit nu este cifra zecimală.'); var nr : byte; begin write('Cititi un numar ');readln(nr); case nr of 0..9 : writeln('CIFRA ZECIMALĂ');

els end nd. e

roblema 3. Se citeşte o literă şi se determină dacă aceasta este vocală sau consoană. P

Rezolvarea problemei: Date de intrare: litera l.

nu s-a citit o literă. Date de ieşire: se afişează un mesaj dacă litera citită este vocală, consoană sauuncţia programului: se determină dacă litera citită este vocală sau consoană. F


eamnă: Litera îns început

tera '); citeşte(l); scrie('Cititi o li lm:=upcase(l); în caz că lm este

U’ : scrie(‘Vocală’); ‘A’,’E’,’I’,’O’,’ altfel

ie(‘Consoană’) dacă (lm>’A’) and (lm<=’Z’) atunci scrltfel scrie(‘Nu s-a introdus o literă.’) a

gata fârşit. s

Programul Pascal: program litera;

m : char; var l,lbegin

tera ');read(l); write('Cititi o lie(l); lm:=upcas

case lm of ','I','O','U' : write('Vocala'); 'A','E

else onsoana') if (lm>'A') and (lm<='Z') then write('C

else write('Nu s-a introdus o litera.') end end.

roblema 4. Se citeşte numărul de ordine al unei luni calendaristice şi se va afişa anotimpul corespunzător acestei luni. P

Rezolvarea problemei: Date de intrare: numărul unei luni, luna. Date de ieşire: Denumirea anotimpului corespunzător lunii calendaristice.


48

uncţia programului: se determină anotimpul din care face parte luna calendaristică. F


înseamnă: Anotimp început l lunii = ’); scrie(‘Număru

citeşte(luna); în caz că luna este 12,1,2 : scrie(‘IARNA’);

ARA’); 3..5 : scrie(‘PRIMĂV 6..8 : scrie(‘VARA’); 9..11 : scrie(‘TOAMNA’);

altfel scrie(‘Nu este numărul unei luni’); ata g

fârşit. s

Programul Pascal:

; program anotimpna : 1..12; var lu

begin ul lunii = ');readln(luna); write('Numar

case luna of 12,1,2 : writeln('IARNA');

ARA'); 3..5 : writeln('PRIMAV 6..8 : writeln('VARA'); 9..11 : writeln('TOAMNA');

lse writeln('Nu este numarul unei luni.') e end end.

roblema 5. Se dau trei numere a, b, c. Să se testeze dacă ele pot fi lungimi ale laturilor unui triunghi. P

Rezolvarea problemei: Date de intrare: numerele a, b, c.

. Date de ieşire: se afişează un mesaj dacă cele trei numere pot fi lungimi ale laturilor unui triunghiuncţia programului: se determină dacă numerele a, b, c pot fi lungimi ale laturilor unui triunghi. F


înseamnă: Triunghi început scrie(‘a = ’); citeşte(a); scrie(‘b = ’); citeşte(b); scrie(‘c = ’); citeşte(c); în caz că (a>0) ŞI (b>0) ŞI (c>0) ŞI (a+b>c) ŞI (a+c>b) ŞI (b+c>a) este

adevărat : scrie('Lungimile date pot forma un

fals : scrie('Lungimile date nu pot forma un .');

gata

triunghi.'); riunghit

sfârşit. Programul Pascal


49

);readln(c);

alse : writeln('Lungimile date nu pot forma un triunghi.');

end.

program triunghi; var a,b,c : integer; begin write('a = ');readln(a); write('b = ');readln(b); write('c = '

case (a>0) and (b>0) and (c>0) and (a+b>c) and (a+c>b) and(b+c>a) of

true : writeln('Lungimile date pot forma un triunghi.'); f end


50

2.2.5. TESTE TEST 1 T1.1. Ce determină executarea următorului program? var b : string[2]; begin readln(b); case b of ‘d’ : write(‘Litera d.’); ‘n’ : write(‘Litera n’); end end. T1.2. Se consideră declaraţiile: var b : boolean; h : real; k : longint;

Indicaţi instrucţiunile case corect scrise.

a) case b of true : writeln(‘adevarat’); false : writeln(‘fals’);

end; b) case h of

4.0 : writeln(‘patru’); 5.0 : writeln(‘cinci’); 6.0 : writeln(sase);

end; c) case k of

10 : writeln(‘zece’); 100 : writeln(‘suta’);

end; T1.3. Se consideră declaraţiile: Var l, m, n : integer; v : boolean; a, q : single;

După efectuarea următoarelor operaţii alegeţi care este varianta corectă pentru valoarea variabilei a.

a) l:=1; a:=1.0;

case l of 2 : begin writeln(‘nr. par’); a:=2.0 end; 1 : begin write(‘nr. impar’); a:=3.0 end; else write(‘Nr. diferit de 1 si 2.’) end;

Răspunsul este: I) 1.0 II) 2.0 III) 3.0. b) m:=4; n:=1; v:=(m>2) and (n<2);

case v of false : a:=0.0; true : a:=1.0; else a:=2.0; end;

Răspunsul este: I) 0.0 II) 1.0 III) 2.0 c) q:=3.0; a:=0.0; read(n);

case n of 1 : a:=1.0; 2 : a:=2.0; 3 : a:=3.0; end; a:=4.0;

Răspunsul este: I) 4.0 II) 0.0 III) 3.0.


probleme. Se citeşte o literă şi se stabileşte dacă este majusculă.


51

TEST 2 T2.1. Ce determină executarea următorului program? var a : boolean; begin a:=true; case a of false : writeln(‘FALS’); true : writeln(‘ADEVĂRAT’); end end. T2.2. Se consideră declaraţiile: Var a : shortint; l, m : char; s : string;

Indicaţi instrucţiunile case incorect scrise.

a) case s of ‘da’ : writeln(‘DA’); ‘nu’ : writeln(‘NU’); else writeln(‘posibil’);

end; b) case l of

‘a’ : begin m:=upcase(l); writeln(m) end; ‘b’ : writeln(‘B’); end;

c) case a of -128 : writeln(‘Limita inferioară.’) 127 : writeln(‘Limita superioară’);

end; T2.3. Se consideră declaraţiile: Var v : boolean; a, b : byte; c, d : real;

După efectuarea următoarelor operaţii alegeţi care este varianta corectă pentru valoarea variabilei v.

a) b:=2; c:=2.0;

v:=(b>=2) or (c>=2); case v of true : writeln(‘condiţie adevarata’); false : writeln(‘condiţie falsă’); end;

Răspunsul este: I) false II). true b) a:=4;

case a of 10 : begin writeln(‘Elev de nota 10.’); v:=true end; else v:=false; end;

Răspunsul este: I) true II).false. c) d:=5.0;

b:=8; case b of 1,2,3,4 : begin

write(‘Nepromovat’); v:=(d>=5) and (b>=5) end;

else if (b>4) and (b<11) then v:=false; end;

Răspunsul este: I) false II) true.


probleme. Se citeşte un număr natural şi să se afişeze dacă este

de ordinul unităţilor, zecilor, sutelor sau miilor.


52

TEST 3 T3.1. Ce determină executarea următorului program? const c=0; var b : byte; begin b:=5; case b of 0 : writeln(c); 1 : writeln(c+1); 2 : writeln(c+2); end; writeln(b) end. T3.2. Se consideră declaraţiile: Var g, h : integer; j : real;

Indicaţi instrucţiunile case corect scrise.

a) case g of 10..99 : writeln(‘sute’); 100..999 : write(‘zeci’);

end; b) case j of

0..9 : write(‘unitati’); else writeln(‘nu sunt unitati’)

end; c) case odd(h) of

true : write(‘impar’); false : write(‘par’);

end;

T3.3. Se consideră declaraţiile: Var q : shortint; b : real; a : integer;

După efectuarea următoarelor operaţii alegeţi care este varianta corectă pentru valoarea variabilei q.

a) b:=4.6;

case (b>4) of true : q:=1; false : q:=0; end;

Răspunsul este: I) 0.0 II) 0 III) 1. b) a:=10; q:=3;

case succ(a) of 10 : q:=4; 11 : q:=5; end;

Răspunsul este: I) 3 II) 5 III) 4. c) q:=20;

case ord(q)>20 of false : q:=21; true : q:=22 end;

Răspunsul este: I) 21 II) 22 III) 20.


probleme. Se citeşte un număr şi se afişază dacă este pozitiv,

negativ sau zero.



53

1. Se citeşte numărul de ordine al unei zile a săptămânii şi se verif ică dacă este lucrătoare sau nelucrătoare.

2. Se citeşte numărul de ordine al unei luni calendaristice şi se va af işa denumirea acesteia şi anotimpul corespunzător acestei luni.

3. Se citeşte un număr întreg şi să se af işeze dacă este de ordinul unităţ ilor, zecilor, sutelor sau miilor.

4. Se citesc două numere de ordinul zecilor, a şi b. Dacă a este pozitiv, atunci se af işează diferenţa dintre a şi b, în caz contrar, se af işează suma dintre a şi b.

5. Se citeşte un număr natural n cuprins între 2 şi 7. Să se af işeze numele poligonului convex cu n laturi.

6. Se citeşte un număr natural şi se af işează dacă este par sau impar.

7. Se citeşte vârsta unei persoane (exprimată în ani) şi se af işează dacă este majoră sau minoră.

8. Fie n= xzy un număr natural de trei cif re. Cunoscând numai cif rele x, y şi z, să se testeze dacă n este divizibil cu numărul 3.

9. . Fie n= vxyz un număr natural de patru cif re. Cunoscând numai cif rele v, x, y şi z, să se testeze dacă n este divizibil cu numărul 11.

10. Se citesc numerele nenule n ş i m. Dacă cele două numere sunt pozitive atunci se acestora, în caz contrar – se calculeacestora.

11. S

calculează suma ază produsul

ă se apese o tastă ş i să se afişeze cărui t ip de taste îi apar ţ ine.

Rezolvaţi problemele utilizând limbajul de programare Pascal.


RĂSPUNSURI Structura alternativă. 1. Instrucţiunea IF Test 1. T1.1. Eroare, deoarece pe ramura lui then se găsesc două instrucţiuni.Corect ar fi ca pe ramura lui then să avem instrucţiunea begin b:=b+c; a:=a+c end. T1.2. a, c. T1.3. a) III; b) II; c) I. T1.4. Programul Pascal citeşte două numere de tip byte(d şi n) şi afişază mesajul ‘Da.’ dacă d este divizor al lui n sau mesajul ‘Nu.’ dacă d nu este divizor al lui n. T1.5. program vocala; var l,lm : char;

begin write('Citiţi o litera ');readln(l); lm:=upcase(l); if (lm='A') or (lm='E') or (lm='I') or (lm='O') or (lm='U') then writeln(l,' este vocală.') end.

Test 2.T2.1. Eroare, deoarece s-a scris ‘;’ înaintea lui else. T2.2. a. T2.3. a) III; b) II; c) I. T2.4. Programul Pascal citeşte de la tastatură un număr real şi afişază un mesaj corespunzător dacă numărul este zero, pozitiv sau negativ. T2.5. program divizibil_3; var x,y,z : byte; begin

write('x=');readln(x); write('z=');readln(z); write('y=');readln(y); if (x+y+z) mod 3 = 0 then write(x,z,y,' este divizibil cu 3.') else write(x,z,y,' nu este divizibil cu 3.') end.

Test 3.T3.1. Eroare, deoarece condiţia pusă (b:=0) nu este expresie booleană, ci instrucţiune de atribuire. T3.2. a. T3.3. a) I; b) II; c) III. T3.4. Programul Pascal citeşte trei numere de tip word şi determină dacă acestea sunt numere pitagorice. T3.5. program isoscel; var a,b,c : integer; begin write('a=');readln(a); write('b=');readln(b);

write('c=');readln(c); if (a>0) and (b>0) and (c>0) and (a+b>c) and (b+c>a) and (a+c>b) then if (a=b) or (b=c) or (a=c) then writeln('Laturile formează un triunghi isoscel.') else writeln('Laturile nu formează un triunghi isoscel.') else writeln('Nr. date nu pot forma un triunghi.') end.

54


Probleme propuse. 1. program pozitiv_negativ; var n : double; begin write('Citiţi un număr '); readln(n); if n>0 then write(n,' este pozitiv.') else if n<0 then write(n,' este negativ.') else write('S-a citit zero.') end. 2. program numere; var n, m : double; begin write('n = '); readln(n);

55

write('m = '); readln(m); if (n>0) and (m>0) then write('Suma = ',n+m:5:2) else write('Produsul = ',n*m:5:2) end. 3. program fracţie; var x, y : integer; begin write('x = '); readln(x); write('y = '); readln(y); if abs(x)<abs(y) then write(y/x:5:2) else write('Fracţia este supraunitară.') end. 4. program numere; var a, b : real;

begin write('a = ');readln(a); write('b = ');readln(b); if a<>b then if a<b then write(b:5:2,'-',a:5:2,'=',b-a:5:2) else write(a:5:2,'-',b:5:2,'=',a-b:5:2) else write('Numerele citite sunt egale.') end. 5. program minim; var x,y,z : integer; begin write('x=');readln(x); write('y=');readln(y); write('z=');readln(z); if x<y then if x<z then write('Minim=',x) else if y<z then write('Minim=',y) else write('Minim=',z) else if y<z then write('Minim=',y) else if x<z then write('Minim',x) else write('Minim=',z) end. 6. program crescător1; var a,b,c : integer; begin write('a=');readln(a);


56

write('b=');readln(b); write('c=');readln(c); if a<b then if b<c then write(a,',',b,',',c) else if c>a then write(a,',',c,',',b) else write(c,',',a,',',b) else if a<c then write(b,',',a,',',c) else if b<c then write(b,',',c,',',a) else write(c,',',b,',',a) end. Sau: Program crescător2; var a,b,c,aux : integer; begin readln(a,b,c); if a>b then begin aux:=a; a:=b; b:=aux end; if b>c then begin aux:=b; b:=c; c:=aux end; if a>b then begin aux:=a; a:=b; b:=aux end; write(a,' ',b,' ',c) end. 7. program descrescător1; var a,b,c : integer; begin write('a=');readln(a);

write('b=');readln(b); write('c=');readln(c); if a>b then if b>c then write(a,',',b,',',c) else if a>c then write(a,',',c,',',b) else write(c,',',a,',',b) else if a>c then write(b,',',a,',',c) else if b>c then write(b,',',c,',',a) else write(c,',',b,',',a) end. Sau: program descrescător2; var a,b,c,aux : integer; begin readln(a,b,c); if a<b then begin aux:=a; a:=b; b:=aux end; if b<c then begin aux:=b; b:=c; c:=aux end; if a<b then begin aux:=a; a:=b; b:=aux end; write(a,' ',b,' ',c) end. 8. program divizor; var x,y : longint; begin write('x = ');readln(x);


57

write('y = ');readln(y); if y mod x = 0 then write(x,' este divizor al lui ',y) else write(x,' nu este divizor al lui ',y) end. 9. program divizibil; var n,m : longint; begin write('n = ');readln(n); write('m = ');readln(m); if n mod m = 0 then write(n,' este divizibil cu ',m) else write(n,' nu este divizibil cu ',m) end. 10. program divizibil_3; var a : longint; begin write('a = ');readln(a); if a mod 3 = 0 then write(a,' este divizibil cu ',3) else write(a,' nu este divizibil cu ',3) end. 11. program divizibil_4; var n : longint; begin write('n = ');readln(n); if n mod 4 = 0 then write(n,' este divizibil cu ',4) else write(n,' nu este divizibil cu ',4) end. 12. program vârsta; var v : integer;

begin write('Vârsta = ');readln(v); if (v<1) or (v>130) then write(v,' nu poate fi vârsta unei persoane.') else if v<18 then write('Persoana este minoră.') else write('Persoana este majoră.') end. 13. program litera; var l,lm : char; begin write('Litera=');read(l); lm:=upcase(l); if (lm='A') or (lm='E') or (lm='I') or (lm='O') or (lm='U') then write('Vocala') else if (lm>'A') and (lm<='Z') then write('Consoana') else write('Nu s-a introdus litera.') end. 14. program divizibil_9; var x,y,z,s : byte; begin write('x=');readln(x); write('z=');readln(z); write('y=');readln(y); s:=x+y+z; if s mod 9 = 0 then write(x,z,y,' este divizibil cu 9.') else write(x,z,y,' nu este divizibil cu 9.') end. 15. program divizibil_7; var v,x,y,z : byte; n : word;


58

begin write('v=');readln(v); write('x=');readln(x); write('y=');readln(y); write('z=');readln(z);

n:=z+y*10+x*100+v*1000; if n mod 7 = 0 then write(n,' este divizibil cu 7.') else write(n,' nu este divizibil cu 7.') end.

2. Instrucţiunea CASE Test 1. T1.1. Eroare, deoarece selectorul instrucţiunii case nu este expresie ordinală. T1.2. a, c. T1.3. a) III; b) II; c) I. T1.4. program majuscula; var l : char; begin write('Litera = ');readln(l);

case l of 'A'..'Z' : writeln('Este MAJUSCULĂ.'); else writeln('Nu este majusculă.') end end.

Test 2. T2.1. Se afişază pe ecran mesajul ‘ADEVĂRAT’. T2.2. a. T2.3. a) II; b) II; c) I. T2.4. program număr; var nr : word; begin write('nr = ');readln(nr); case nr of

0..9 : writeln(nr,' este de ordinul unităţilor'); 10..99 : writeln(nr,' este de ordinul zecilor'); 100..999 : writeln(nr,' este de ordinul sutelor'); 1000..9999 : writeln(nr,' este de ordinul miilor'); else writeln(nr,' este de ordin mai mare decât al miilor.') end end.

Test 3. T3.1. Se afişază pe ecran valoarea variabilei b, adică 5. T3.2. a, c. T3.3. a) III; b) II; c) I. T3.4. program pozitiv_negativ; var n : real; begin

write('n = ');readln(n); case n>0 of true : writeln(n:5:2,' este pozitiv.'); false : if n=0 then writeln(n:4:2,' este zero.') else writeln(n:5:2,' este negativ.') end end.


59

Probleme propuse. 1. program zi_lucrătoare; var zi : 1..7; begin write('Nr. de ordine al zilei ');readln(zi); case zi of 1..5 : writeln('Zi lucrătoare'); 6,7 : writeln('Zi nelucrătoare'); else writeln('Nu este nr. de ordine al unei zile.') end end. 2. program lună_anotimp; var luna : 1..12; begin write('Numarul lunii = ');readln(luna); case luna of 12 : begin write('Luna decembrie');write(' IARNA') end; 1 : begin write('Luna ianuarie'); write(' IARNA') end; 2 : begin write('Luna februarie');write(' IARNA') end; 3 : begin write('Luna martie');write(' PRIMAVARA') end; 4 : begin write('Luna aprilie');write(' PRIMAVARA') end; 5 : begin write('Luna mai');write(' PRIMAVARA') end; 6 : begin write('Luna iunie');write(' VARA') end; 7 : begin write('Luna iulie');write(' VARA') end; 8 : begin write('Luna august');write(' VARA') end; 9 : begin write('Luna septembrie');write(' TOAMNA') end; 10 : begin write('Luna octombrie');write(' TOAMNA') end; 11 : begin write('Luna noiembrie');write(' TOAMNA') end; else writeln('Nu este numarul unei luni.') end; writeln end.

3. program număr; var nr : integer; begin write('nr = ');readln(nr); case nr of -9..9 : writeln(nr,' este de ordinul unitătilor'); -99..-10,10..99 : writeln(nr,' este de ordinul zecilor'); -999..-100,100..999 : writeln(nr,' este de ordinul sutelor'); -9999..-1000,1000..9999 : writeln(nr,' este de ordinul miilor'); else writeln(nr,' este de ordin mai mare decât al miilor.') end end. 4. program numere; var a,b : integer; begin write('a = ');readln(a); write('b = ');readln(b); case a of 10..99 : case b of -99..-10,10..99 : writeln(a,'-',b,'=',a-b); else writeln(b,' nu este de ordinul zecilor.') end; -99..-10 : case b of -99..-10,10..99 : writeln(a,'+',b,'=',a+b); else writeln(b,' nu este de ordinul zecilor.') end; else writeln(a,' nu este de ordinul zecilor.') end end.


60

5. program figura; var nr : byte; begin write('nr = ');readln(nr); case nr of 3 : writeln('Triunghi'); 4 : writeln('Patrulater'); 5 : writeln('Pentagon'); 6 : writeln('Hexagon'); 7 : writeln('Heptagon'); else if nr<3 then writeln('S-a citit un număr mai mic decât 3') else writeln('S-a citit un numar mai mare decat 7') end end. 6. program par_impar; var n : word; begin write('Numărul natural = ');readln(n); case odd(n) of true : writeln(n,' este impar'); false : writeln(n,' este par'); end end. 7. program minor_major; var v : integer; begin write('Vârsta persoanei = ');readln(v); case v of 1..17 : writeln('Persoana este minoră);

else if (v<1) or (v>130) then writeln('Vârsta imposibilă') else writeln('Persoana este majora'); end end. 8. program număr; var x,y,z : byte; begin write('x = ');readln(x); write('y = ');readln(y); write('z = ');readln(z); case (x+y+z) mod 3 = 0 of true : writeln(x,z,y,' este divizibil cu 3.'); false : writeln(x,z,y,' nu este divizibil cu 3.'); end end. 9. program divizibil_11; var v,x,y,z : byte; begin write('v = ');readln(v); write('x = ');readln(x); write('y = ');readln(y); write('z = ');readln(z); case (z+y*10+x*100+v*1000) mod 11 = 0 of true : writeln(v,x,y,z,' este divizibil cu 11.'); false : writeln(v,x,y,z,' nu este divizibil cu 11.'); end end. 10. program calcule; var m,n : double;


61

begin write('m = ');readln(m); write('n = ');readln(n); case (m>0) and (n>0) of true : writeln('Suma este ',m+n:5:2); false : writeln('Produsul este ',m*n:5:2); end; end. 11. program tip_tastă; var tastă : char;

begin write('Apăsaţi o tastă ');readln(tastă); case tasta of 'a'..'z','A'..'Z' : writeln('Literă); '0'..'9' : writeln('Cifra zecimală'); else writeln('Tasta specială'); end end.

Culegere de probleme Structura repetitivă

2.3. STRUCTURA REPETITIVĂ 2.3.1. Instrucţiunea WHILE Instrucţ iunea while descrie structura repetitivă (ciclică ) cu test iniţ ial. Ea se mai numeşte instrucţ iune de ciclare (ciclu) cu test iniţ ial sau instrucţ iune de ciclare condiţ ionată anterior. Are forma:

while expresie (booleană) do instruc ţ iune;

Diagrama de sintaxă a acestei instrucţ iuni este următoarea: Instrucţiunea

while

while expresie(booleană) do instrucţiune Expresia din diagramă se numeşte condiţ ie de ciclare, iar instrucţ iunea reprezintă corpul ciclului. Executarea instrucţ iunii while constă în următoarele:

1) -se evaluează expresia booleană; 2) -dacă expresia are valoarea true, se execută instrucţiunea specificată după cuvântul cheie do şi se revine la pasul 1;

-dacă expresia are valoarea false, executarea programului continuă cu instrucţiunea care urmează după instrucţiunea while. Problema 1. 1. Să se calculeze suma S=1+ 2 +…+ n. Rezolvarea problemei: Date de intrare: numărul întreg pozitiv n. Date de ieşire: suma ş i produsul primelor n numere întregi pozitive. Funcţ ia programului: Determină suma S=1+2+…+n ş i produsul P=1*2*..*n. Pentru aceasta se iniţ ializează suma cu zero ş i produsul cu 1. Vom folosi o variabilă i care va primi pe rând valorile celor n numere. Iniţ ial lui i î i vom atribui valoarea 1. Trecerea la numărul următor se realizează prin mărirea lui i cu 1(incrementarea lui i ) .

62


63

NU DA

Algoritmul în pseudocod: Suma_produs_n înseamnă: Început Scrie( ‘n>0: ’ ) ;citeşte(n); S:=0; P:=1; i:=1; Cât timp i <=n execută Început S:=S+i;

P:=P*i; i:=i+1

sfârş it; scrie( ‘Suma este=’,S); scrie( ‘Produsul este=’,P) sfârş it.

Programul Pascal: START

Program sumă_produs_n; var i ,s,p,n:integer; CITESTE n begin write(‘n>0: ’);readln(n); S:=0 s:=0; p:=1; P:=1 i :=1; while i<=n do i:=1 begin s:=s+i; p:=p*i; i<=n SCRIE S i :=i+1 end; S:=S+i SCRIE P write(‘Suma este ’,s); write(‘Produsul este ’,p)

P:=P*i readln STOP end.

i:=i+1

Problema 2. Aflaţ i numerele naturale x ş i y ştiind că . 180y*xx 23

Rezolvarea problemei: Date de intrare: nu se introduc date de la tastatură. Date de ieşire: valorile lui x ş i y; Funcţ ia programului: Determină valorile lui x ş i y care verifică egalitatea . Valorile posibile ale

lui x sunt:

180y*xx 23

5,1 . Valorile posibile ale lui y sunt 179,1 . Iniţ ial lui x î i vom atribui valoarea 1.Pe rând pentru fiecare valoare a lui x se testează valorile posibile ale lui y ş i se verifică care îndeplinesc egalitatea. Trecerea de la o valoare la alta atât pentru x cât ş i pentru y se realizează prin mărirea variabilelor cu 1.


64

DA NU NU DA NU DA

Algoritmul în pseudocod: Numere înseamnă: Început x:=1; cât timp x<=5 execută început y:=1; cât timp y<=179 execută început dacă x*x*x+x*x*y=180 atunci scrie(x, ’ ‘ ,y); y:=y+1; sfârş it; x:=x+1; sfârş it sfârş it.

Programul Pascal:

STOP

START

x:=1

x<=5 y:=1

x3+x2*y=18

y<=179

SCRIE x,y

y:=y+1

x:=x+1

program numere; var x,y:byte; begin x:=1; while x<=5 do begin y:=1; while y<=179 do begin i f x*x*x+x*x*y=180 then writeln(x, ' ' ,y); y:=y+1; end; x:=x+1; end; readln end.

Problema 3. Să se determine numerele de forma 3b2a care sunt divizibile cu 11 unde a, b sunt cifre zecimale. Rezolvarea problemei: Date de intrare: nu se introduc de la tastatură. Date de ieşire: numerele de forma 3b2a divizibile cu 11. Funcţ ia programului: Determină valorile lui a ş i b pentru care numerele de forma 3b2a sunt divizibile cu 11. Valorile posibile ale lui a sunt 1,9 , iar ale lui b sunt 0,9 .Pentru ca a2b3 să fie divizibile cu 11 trebuie ca restul împărţ irii acestor numere la 11 să f ie zero.


65

NU DA NU DA DA NU

START

a:=a+1

a<=9

b:=0

b<=9

a*1000+2*100+b*10+3=0

Scrie a,'2',b,'3'

b:=b+1

a:=1

STOP

Algoritmul în pseudocod: Div_11 înseamnă: Început a:=1; cât timp a<=9 execută început b:=0; cât timp b<=9 execută început dacă (a*1000+b*10+203)mod11=0 atunci scrie(a, ’2’,b, ’3’); b:=b+1; sfârş it; a:=a+1; sfârş it; sfârş it.

Programul Pascal: program div_11; var a,b:byte; begin a:=1; while a<=9 do begin b:=0; while b<=9 do begin i f (a*1000+b*10+203) mod 11=0 then writeln(a, '2',b, '3', ' ' ) ; b:=b+1; end; a:=a+1; end; readln end.


Problema 4. Să se afişeze toţ i divizorii numărului natural nenul n. Rezolvarea problemei: Date de intrare: numărul natural nenul n. Date de ieşire: divizorii numărului natural nenul n. Funcţ ia programului: Determină divizorii numărului natural nenul n. Pentru a verifica dacă un număr natural nenul d este divizor al numărului n vom testa dacă restul împărţ irii lui n la d este zero(n mod d=0).Ştim că orice număr natural n, diferit de 0 ş i 1 are ca divizori improprii numerele 1 ş i n. Divizorii

proprii vor fi printre numerele dp,2 unde dp= ⎥⎦⎤

⎢⎣⎡2n

. Dacă n=1 atunci singurul său divizor este 1.

Exemplu: Pentru n=50: -divizorii să i sunt:1, 2, 5, 10, 25, 50. -divizorii improprii sunt: 1, 50. -divizorii proprii sunt: 2, 5, 10, 25.

66

NU DA NU DA DA NU

Algoritmul în pseudocod: Divizori înseamnă: srie('n>0:'); citeşte(n); scrie('Divizorii lui ',n,' sunt: 1 '); dacă n>1 atunci început dp:= n div 2; d:=2; cât timp d<=dp execută început dacă (n mod d=0) atunci scrie(d,' '); d:=d+1; sfârşit; scrie(n); sfârşit; sfărşit.

Programul Pascal: START Citeste n program divizori; var n,d,dp:integer; begin write('n>0:'); readln(n); write('Divizorii lui ',n,' sunt: 1 '); if n>1 then begin dp:= n div 2; d:=2; while d<=dp do begin if (n mod d=0) then write(d,' '); d:=d+1; end; writeln(n); end; readln end.

Scrie n>1 (Divizorii lui,'n',sunt:1 ')

dp:=ndiv2

d:=2

nmodd=0 d<=dp

Scrie d Scrie n

d:=d+1 STOP


Problema 5. Se dau două numere având acelaş i număr de cifre. Câte cifre trebuie modificate pentru a transforma un număr în celă lalt? (De exemplu, pentru numerele 2135 ş i 7139 este necesară modificarea a două cifre). Rezolvarea problemei: Date de intrare: cele două numere date de variabilele n1 ş i n2. Date de ieşire: numărul de cifre care trebuie modificate dat de variabila nr. Funcţ ia programului: Determină numărul de cifre care trebuie modificate. Se compară numerele cifră cu cifră. Pentru a obţ ine cifrele unui număr se fac împărţ iri succesive la 10, resturile obţ inute fiind cifrele numarului. Iniţ ial, nr are valoarea zero. Dacă se găsesc două cifre diferite mărim valoarea lui nr cu 1.

67

NU DA DA NU

Algoritmul în pseudocod: numere_egale înseamnă: început scrie( 'n1='); citeşte(n1); scrie( 'n2='); citeşte(n2); nr:=0; cât timp n1<>0 execută început r1:=n1 mod 10; r2:=n2 mod 10; dacă r1<>r2 atunci nr:=nr+1; n1:=n1 div 10; n2:=n2 div 10; sfârş it; scrie( 'Nr. de cifre ce trebuie modificate = ',nr) sfârş it.

START

Citeşte n1 Program Pascal: program numere_egale; var Citeste n2 n1,n2,r1,r2:longint; nr : byte; begin write('n1=');readln(n1); write('n2=');readln(n2); nr:=0; while n1<>0 do begin r1:=n1 mod 10; r2:=n2 mod 10; i f r1<>r2 then nr:=nr+1; n1:=n1 div 10; n2:=n2 div 10; end; write('Nr. de cifre ce trebuie modif icate = ' ,nr) end.

nr:=0

r1<>r2

r2:=n2mod10

r1:=n1mod10

n1<>0

nr:=nr+1

n1:=n1div10

n2:=n2div10

STOP

Scrie nr



1. Calculaţ i: a) S=1 2 -2 +3 -… 2 2 2n±

b) S=432

1+

5432

+ …+)3()2()1( nnn

n

c) S=1+2

1+

31

+…+n

1

d) P=(1- 221

) (1-• 231

) (1- 241

)…(1- 2n1

)

2. Să se determine numerele formate din cinci cif re de forma abcde care dau restul 12 la împărţ irea cu 1999.

3. Se citesc n numere de la tastatură. Să se af işeze numerele divizibile cu 5.

4. Să se determine cif rele x şi y astfel încât

915xy єN.

5 .Să se determine numerele de forma xyz72 divizibile cu 36.

68

6. Găsiţ i f racţ iile de forma 30

32 yx ireductibile.

7. Să se calculeze media aritmetică şi media geometrică a primelor n numere întregi pozitive.

8. Să se determine fracţ iile de forma y3xa5b7 care se

simplif ică cu 18.

9. Să se calculeze suma şi produsul divizorilor proprii ai unui număr citit.

10. Un număr este perfect dacă este egal cu suma divizorilor săi (excluzându-l pe el). Exemplu 6=1+2+3. Să se determine dacă un număr întreg dat este perfect sau nu.

11. Se dă un număr natural n. Să se determine cif ra maximă din număr.

12.Să se verif ice dacă un număr natural este palindrom sau nu(un număr este palindrom dacă el coincide cu numărul format din cif rele sale luate în ordine inversă) .

13.Af laţ i a şi b astfel încât a *(a+b)=168. 2

14.Să se verif ice dacă un număr natural n este prim sau nu.


69

REZOLVAREA PROBLEMELOR 1.a program suma1; var i ,n,semn,S:integer; begin write('n='); readln(n); S:=0; i :=1; semn:=1; while i<=n do begin S:=S+semn*sqr(i); i :=i+1; semn:=-semn; end; write('Suma este =',S); readln end. 1.b. program w1b; var i ,n:integer; s:real; begin write('n='); readln(n); i :=1; s:=0; while i<=n do begin s:=s+i/(( i+1)*(i+2)*(i+3)); i :=i+1;

end; write('Suma este=',s:5:2); readln end. 1.c. program sumac; var i ,n:integer; s:real; begin write('n='); readln(n); s:=0; i :=1; while i<=n do begin s:=s+1/sqrt( i); i :=i+1; end; write('Suma este=',s:5:2); readln end. 1.d. program w1d; var i ,n:byte; p:real; begin write('n='); readln(n); i :=2;


70

p:=1; while i<= n do begin p:=p*(1-1/sqr(i)); i :=i+1; end; writeln('produsul este=',p:6:4); readln end. 2. program w_2; var a,b,c,d,e:byte; begin a:=1; while a<=9 do begin b:=0; while b<=9 do begin c:=0; while c<=9 do begin d:=0; while d<=9 do begin e:=0; while e<=9 do begin i f (a*10000+b*1000+c*100+d*10+e)mod 1999=12 then write(a,b,c,d,e, ' ' ) ; e:=e+1; end; d:=d+1;

end; c:=c+1; end; b:=b+1; end; a:=a+1; end; readln end. 3. program divizibi le; var n,nr, i : integer; begin i:=1; write('n='); readln(n); while i<=n do begin write('nr='); readln(nr); i f nr mod 5=0 then writeln(nr, ' este divizibi l cu 5') i :=i+1; end; readln end. 4. program nr_apar ţ ine; var x,y:byte; begin x:=0; while x<=9 do begin


71

y:=0; while y<=9 do begin i f sqrt(15009+x*100+y*10)=int(sqrt(15009+x*100+y*10) then write('15',x,y, '9'); y:=y+1; end; x:=x+1; end; readln end. 5. program divizibi le; var x,y,z:byte; begin x:=0; while x<=9 do begin y:=0; while y<=9 do begin z:=0; while z<=9 do begin i f ((72000+x*100+y*10+z) mod 36=0) then write('72',x,y,z, ' ' ) ; z:=z+1; end; y:=y+1; end; x:=x+1; end; end.

6. program frac ţ i i ; var x,y:byte; begin x:=0; while x<=9 do begin y:=0; while y<=9 do begin i f ((2030+x*100+y)mod 2<>0) and((2030+x*100+y)mod 3<>0) and((2030+x*100+y)mod 5<>0) then write(' 2',x, '3',y, ' / ' , '30 ') ; y:=y+1; end; x:=x+1; end; readln end. Sau program fractii; var x,y:byte; begin x:=0; while x<=9 do begin y:=1; while y<=9 do begin if (( y<>2) and(y<>4) and (y<>6) and (y<>8)) and((5+x+y)mod 3<>0)and(y<>5) then write(' 2',x,'3',y,'/','30 '); y:=y+1;


72

end; x:=x+1; end; readln end. 7. program media_a_g; var i ,n,s,p:integer; ma,mg:real; begin write('n>0:'); readln(n); i :=1; s:=0; p:=1; while i<=n do begin s:=s+i; p:=p*i; i :=i+1; end; ma:=s /n; writeln('Media aritmetică este ' ,ma:6:3); mg:=sqrt(p); write('Media geometrică este ' ,mg:6:3); readln end. 8. program simplif_18; var a,b,x,y:byte; begin b:=0; while b<=9 do begin a:=0;

while a<=9 do begin x:=1; while x<=9 do begin y:=0; while y<=9 do begin i f (((7050+b*100+a)mod 18=0) and ((x*100+30+y)mod 18=0)) then write('7',b, '5',a, ' / ' ,x, '3',y, ' ' ) ; y:=y+1; end; x:=x+1; end; a:=a+1; end; b:=b+1; end; readln end. 9. program suma_prod_div; var n,d,s,p,dp:word; begin write('Nr. este:');readln(n); s:=0; p:=1; if n>1 then begin dp:=n div 2; d:=2; while d<= dp do begin if n mod d=0 then begin s:=s+d;


73

p:=p*d; end; d:=d+1; end; end;

writeln('Suma divizorilor este:',s); writeln('Produsul divizorilor este:',p); readln end.

10. program nr_perfect; var n,d,dp,s,nf:word; begin write('n='); readln(n); s:=1; if n>1 then begin dp:=n div 2; d:=2; while d<=dp do begin if n mod d =0 then s:=s+d; d:=d+1; end; end; if n=s then write(n,' este perfect') else Write(n, ' nu este perfect'); readln end. 11.program cifra_max; var i,max,r:byte; nr:longint; begin write('Introduceţi numărul '); readln(nr); max:=nr mod 10; nr:=nr div 10; while nr<>0 do

begin r:=nr mod 10; if r>max then max:=r; nr:=nr div 10 ; end; write('Cifra maximă este ',max ); readln end. 12. program nr_palindrom; var n,n1,n2:longint; c:byte; begin write('n='); readln(n); n1:=n; n2:=0; while n>0 do begin c:=n mod 10; n2:=n2*10 +c; n:=n div 10; end; if n1=n2 then write(n1,'este palindrom') else write(n1,'nu este palindrom'); end.


74

13. program numere; var a,b:byte; begin a:=1 ; while a<=5 do begin b:=1; while b<=167 do begin if (a*a*(a+b)=168) then write(' ',a,' ',b,' '); b:=b+1; end; a:=a+1; end; readln end. 14. program nr_prim; var n,d:word; prim:boolean;

begin write('n>0:'); readln(n); if n=1 then write(n,'nu este prim') else if n mod 2=0 then if n=2 then write(n,'este prim') else write(n,'nu este prim') else begin prim:=true; d:=3; while d<=trunc(sqrt(n)) do if n mod d=0 then begin prim:=false; d:=n; end else d:=d+2; if prim then write(n,' este prim') else write(n,' nu este prim'); end; readln end.


2.3.3. Instrucţiunea REPEAT Instrucţ iunea repeat descrie structura repetitivă cu test final. Ea se mai numeşte instrucţ iune de ciclare (ciclu) cu test f inal sau instrucţ iune de ciclare condiţ ionată posterior. Are forma:

repeat instruc ţ iune1; instruc ţ iune2; ………………. instruc ţ iunen;

until expresie booleană ; Diagrama de sintaxă a acestei instrucţ iuni este următoarea:

Instrucţiunea

repeat

repeat instrucţiune until expresie(booleană)

;

Expresia din diagramă se mai numeşte condiţ ie de ieşire din ciclu, iar instrucţ iunile cuprinse între repeat ş i until formează corpul ciclului. Executarea instrucţ iunii repeat constă în următoarele: 1) se execută instrucţ iunile cuprinse între repeat ş i unti l; 2) se evaluează expresia booleană: -dacă valoarea ei este false se revine la 1) ş i se execută din nou instruc ţ iune1… instruc ţ iunen; -dacă valoarea expresiei este true, programul continuă cu instrucţ iunea următoare. Observaţ ie: Spre deosebire de instrucţ iunea while corpul instrucţ iunii repeat se execută cel puţ in o dată. Problema 1. Se citeşte un număr natural n. Să se calculeze suma cifrelor sale. Rezolvarea problemei: Date de intrare: numărul natural n. Date de ieşire: suma cifrelor numărului dată de variabila s.

75


Funcţ ia programului: Determină valoarea sumei cifrelor numărului natural n. Cifrele numărului se obţ in prin împărţ iri succesive la zece, resturile obţ inute fiind cifrele numărului.

76

NU DA

START

S:=0

S:=S+n mod 10

Citeşte n

n:=n div 10

n=0

Scrie S

STOP

Algoritmul în pseudocod: suma_cifre înseamnă: început scrie('n='); citeşte(n); s:=0; repetă s:=s + n mod 10; n:=n div 10; până când n=0; scrie('Suma cifrelor numărului citit este ',s); sfârşit.

Programul Pascal: program suma_cifre; var n : longint; s,r : byte; begin write('n='); readln(n); s:=0; repeat s:=s + n mod 10; n:=n div 10; unti l n=0; writeln('Suma cifrelor numărului cit i t este ' ,s); readln end.

Problema 2.

Aflaţ i fracţ i i le de forma yx

7x1 care se simplifică prin 3.

Rezolvarea problemei: Date de intrare: Nu se citesc date de la tastatură.

Date de ieşire :fracţ i i le de forma yx

7x1 care se simplifică cu 3


Funcţ ia programului: Determină valorile lui x ş i y pentru care fracţ i i le de forma yx

7x1 se simplifică cu 3.

Valorile posibile ale lui x sunt 0,9, iar ale lui y sunt 1,9 . Trecerea de la o valoare la alta atât pentru x cât ş i pentru y se realizează prin mărirea variabilelor cu 1. Pentru ca aceste fracţ i i să se simplifice cu 3 trebuie ca numerele 7x1 ş i yx să fie divizibile cu 3.Vom folosi criteriul de divizibilitate cu 3: dacă suma cifrelor unui număr natural este divizibilă cu 3 atunci numărul considerat se divide cu 3.

77

NU NU DA NU DA DA

Algoritmul în pseudocod: Div_3 înseamnă: început x:=0; repetă y:=1; repetă dacă ((8+x) mod 3=0) and ((y+x) mod 3=0) atunci scrie('1',x,'7/',y,x,' ' ); y:=y+1; până când y>9; x:=x+1; până când x>9;

START

x:=0

sfârşit. y:=1 Programul Pascal: program div_3; ((8+x)mod3=0) and var x,y:byte; begin x:=0; repeat y:=1; repeat i f ((8+x) mod 3=0) and ((y+x) mod 3=0) then writeln('1',x, '7/ ' ,y,x, ' ' ) ; y:=y+1; unti l y>9; x:=x+1; unti l x>9; end.

((y+x)mod3=0)

y:=y+1

Scrie('1',x,'7/',y,x)

y>9

x:=x+1 x>9

STOP


Problema 3. Să se determine media aritmetică a n numere întregi pozitive introduse de la tastatură. Rezolvarea problemei: Date de intrare: numărul întregilor pozitivi introduş i de la tastatură este memorat în variabila n , iar numerele respective sunt memorate în variabila nr. Date de ieşire: media aritmetică a celor n numere este memorată în variabila ma. Funcţ ia programului: se determină media aritmetică a celor n numere întregi. Pentru aceasta se calculează mai întâi suma celor n numere apoi aceasta se împarte la n obţ inând astfel media aritmetică.

78

NU DA NU DA

Algoritmul în pseudocod: med_aritm înseamnă: început scrie(‘n=’) citeşte(n); i:=1; s:=0; repetă repetă scrie('nr.',i, 'este='); citeşte(nr); până când nr>0; s:=s+nr; i:=i+1; până când i>n; ma:=s/n; scrie(‘Media aritmetică este=',ma:6:2); sfârşit.

START Programul Pascal: Program med_aritm; Citeşte n var i ,s,n,nr : integer; i:=1 ma : real; begin

S:=0 write('n='); readln(n); i :=1; s:=0; repeat repeat writeln('nr. ' , i , 'este= '); readln(nr); unti l nr>0; s:=s+nr; i :=i+1; unti l i>n; ma:=s/n; write('Media aritmetică este=',ma:6:2); end.

Citeşte nr

nr>o

S:=S+nr

STOP

Scrie ma

ma:=S/n

i>n i:=i+1


Problema 4. Să se determine maximul a n numere introduse de la tastatură. Rezolvarea problemei: Date de intrare: cele n numere care sunt memorate, pe rând, în variabila nr. Date de ieşire: maximul celor n numere memorat în variabila max. Funcţ ia programului: Se determină maximul celor n numere introduse de la tastatură. Max primeşte valoarea primului număr introdus de la tastatură. Se compară max cu nr, dacă nr>max atunci max primeşte valoarea lui nr apoi se trece la numărul următor. În caz contrar se trece la următorul număr. După ce a fost comparat cu toate cele n numere maximul se afişează ş i algoritmul se încheie.

79

NU DA DA NU

Algoritmul în pseudocod: Maxim înseamnă: început scrie('n='); citeşte(n); scrie('Primul număr este :'); citeşte(nr); max:=nr; i:=2; repetă scrie('Numărul ',i,' este:'); citeşte(nr); dacă nr>max atunci max:=nr; i:=i+1; până cândl i>n; scrie('Maximul este:',max); sfârşit.

Programul Pascal: START

Citeşte n Citeşte nr max:=nr

i:=2 Citeste nr

nr>max

max:=nr

i:=I+1

i>n Scrie

maximul este max

STOP

program maxim; var max,nr:integer; i,n:byte; begin write('n='); readln(n); write('Primul număr este :'); readln(nr); max:=nr; i:=2; repeat write('Numărul ',i,' este:'); readln(nr); if nr>max then max:=nr; i:=i+1; until i>n; writeln('Maximul este:',max); readln end.


Problema 5. Să se determine toate numerele naturale de trei cifre care se divid prin suma cifrelor lor. Rezolvarea problemei: Date de intrare: nu sunt introduse date de la tastatură. Date de ieşire: numerele naturale de trei cifre care se divid prin suma cifrelor lor. Funcţ ia programului: se determină numerele naturale de trei cifre care se divid prin suma cifrelor lor. Pentru aceasta se verifică numerele naturale din intervalul [100, 999] dacă îndeplinesc condiţ ia cerută.

START

80

DA NU NU DA DA NU DA NU

Algoritmul în pseudocod: Numere înseamnă: început a:=1; repetă b:=0 ; repetă c:=0; repetă dacă (a*100+b*10+c) mod (a+b+c)=0 atunci scrie(' ',a,b,c,' ') ; c:=c+1 până când c>9; b:=b+1; până când b>9; a:=a+1; până când a>9; sfârşit. .

Programul Pascal: program numere; a:=1 var a,b,c,s:byte; begin

b:=0 a:=1; repeat b:=0 ; (a*100+b*10+c)

mc:=0

od(a+b+c)=0 repeat c:=0; repeat i f (a*100+b*10+c) mod (a+b+c)=0 then write(' ' ,a,b,c, ' ' ) ;

Scrie(a,b,c)

c:=c+1 c:=c+1 unti l c>9;

c>9 b:=b+1; unti l b>9;

STOP a:=a+1; b:=b+1 unti l a>9; end.

a>9 b>9 a:=a+1



1. Calculaţ i:

a) S=1-31

+51

-… ±1-n2

1

b) P=21

·43

·… ·n2

1-n2

c) S=31

14

+53

24

+…+)12()12(

4

nnn

d) S= 22

1- 26

1+… ± 2)24(

1n

2. Să se determine suma pătratelor a n numere întregi introduse de la tastatură.

3. Af laţ i numerele naturale abc ştiind că a şi c sunt impare, iar abc divizibil cu 3.

4.Af laţ i numerele naturale abc ştiind că a şi c sunt pare, iar abc divizibil cu 4.

5 Af laţ i f racţ iile de forma 24

79 xy ireductibile,

unde y este cif ră pară.

6. Se citesc două numere de la tastatură. Să se determine dacă sunt numere gemene (două

numere sunt gemene, dacă sunt prime şi diferenţa dintre cel mai mare şi cel mai mic este 2).

7. Să se determine toate numerele naturale de trei cif re care se divid prin produsul cif relor lor.

8. Se dă un număr întreg. Să se verif ice dacă acest număr este pătrat perfect. Dacă da să se af işeze numărul al cărui pătrat perfect este.

9. Af laţ i x şi y astfel încât x425 şi y1 să f ie prime între ele (cel mai mare divizor comun al lor să f ie 1).

10. Af laţ i numerele prime formate din trei

11. Să se determine mini

cif re .

mul a n numere introduse de la tastatură.

12.Af laţ i numerele prime de ordinul zecilor astfîncât numerele obţ inute prin inve

el rsarea ordinii

cif relor să f ie tot numere prime.

. Să se deter 13 mine numerele naturale de forma

xyz astfel încât yzxy

81


82

REZOLVAREA PROBLEMELOR 1.a) program suma; var i ,n,semn:integer; s:real; begin write('n='); readln(n); i :=1; s:=0; semn:=1; repeat s:=s+semn*(1/(2*i-1)); i :=i+1; semn:=-semn; unti l i>n; write('Suma este=',s:6:2); readln end. b) program produs; var i ,n:integer; p:real; begin write('n='); readln(n); i :=1; p:=1; repeat p:=p*((2*i-1)/(2*i)); i :=i+1; unti l i>n; write('Produsul este ' ,p:6:2); readln end. c) program suma; var i ,n:integer; s:real; begin write('n='); readln(n); i :=1; s:=0; repeat s:=s+sqr(sqr(i))/(2*i-1)*(2*i+1); i :=i+1; unti l i>n; write('Suma este ' ,s:6:2); readln end.

d) program suma; var n,i,semn:integer; s:real; begin write('n='); readln(n); s:=0; i:=1; semn:=1; repeat

s:=s+(semn*1/((4*i-2)*(4*i-2))); i:=i+1; semn:=-semn; until i>n; write('Suma este=',s:6:2); readln end. 2. program suma_nr; var i ,n,nr: integer; s: longint; begin write('n='); readln(n); i :=1; s:=0; repeat write('Nr. ' , i , ' este ' ); readln(nr); s:=s+sqr(nr); i :=i+1; unti l i>n; write('Suma este ' ,s); readln end. 3. program div_3; var a,b,c:byte; begin a:=1; repeat

b:=0; repeat c:=1; repeat i f(a+b+c)mod 3=0 then write(' ' ,a,b,c, ' ' ) ;


83

c:=c+2; unti l c>9;

b:=b+1; unti l b>9; a:=a+2;

unti l a>9; readln end. 4. program div_4; var a,b,c:byte; begin a:=2; repeat b:=0; repeat c:=0; repeat i f (b*10+c)mod 4=0 then write(' ' ,a,b,c , ' ' ) ; c:=c+2; unti l c>8; b:=b+1; unti l b>9; a:=a+2; unti l a>8; readln end. 5. program fractii; var y,x:byte; begin y:=0; repeat x:=1; repeat if ((16+x+y) mod 3<>0) then write('9',y,'7',x,'/6 ');

x:=x+2; until x>9; y:=y+2; until y>9; readln end. 6. program nr_gemene; var nr1,nr2,divz,m:longint; d:byte; prim1, prim2 : boolean; begin write('nr1='); readln(nr1); write('nr2='); readln(nr2); d:=abs(nr1-nr2); if d<>2 then write('Numerele nu sunt gemene') else begin prim1:=true; if nr1 mod 2 = 0 then prim1:=false else begin divz:=3; m:=trunc(sqrt(nr1)) ; repeat if nr1 mod divz = 0 then prim1:=false; divz:=divz+2 until divz > m; end; if not prim1 then write('Numerele nu sunt gemene') else begin prim2:=true; if nr2 mod 2 = 0 then prim2:=false else begin divz:=3; m:=trunc(sqrt(nr2)) ; repeat if nr2 mod divz = 0 then prim2:=false; divz:=divz+2 until divz > m; end; if prim2 then write(nr1,'si',nr2,'sunt gemene') else write('Numerele nu sunt gemene') ;


84

end; end end. 7. program div_prod; var x,y,z:byte; p:word; begin p:=1; x:=1; repeat y:=1; repeat z:=1; repeat p:=x*y*z; if (x*100+y*10+z) mod p=0 then write(x,y,z,' '); z:=z+1; until z>9; y:=y+1; until y>9; x:=x+1; until x>9; end. 8. program nr_patrat; var n:word; begin write('n='); readln(n); if sqrt(n)=int(sqrt(n)) then write('este patratul lui',sqrt(n):6:0) else write('nu este patrat perfect'); readln end. 9. program prime;

var x,y:byte; a,b,r:word; begin x:=0; repeat y:=0; repeat a:=4250+x; b:=10+y; repeat r:=a mod b; a:=b; b:=r; until r=0; if a=1 then write(' 425',x,'/1',y,' '); y:=y+1; until y>9; x:=x+1; until x>9; readln; end. 10. program nr_prime; var n,d:integer; prim:boolean; begin n:=101; repeat prim:=true; d:=3; while d<=trunc(sqrt(n)) do if n mod d=0 then begin

prim:=false; d:=n; end

else d:=d+2; if prim then write(n,' '); n:=n+2; until n>999; readln end. 11. program minim;


85

var min,nr:integer; i,n:byte; begin write('n='); readln(n); write('Primul numar este :'); readln(nr); min:=nr; i:=2; repeat write('Numarul ',i,' este:'); readln(nr); if nr<min then min:=nr; i:=i+1; until i>n; writeln('Minimul este:',min); readln end. 12. program prime; var a,b,nr,nrinv,divz,m: byte;prim1, prim2 : boolean; begin a:=1; repeat b:=1; repeat nr:=a*10+b; prim1:=true; if nr mod 2 = 0 then prim1:=false else begin divz:=3; m:=trunc(sqrt(nr)); repeat if nr mod divz = 0 then prim1:=false; divz:=divz+2 until divz > m; end; if prim1 then begin

nrinv:=b*10+a; prim2:=true; if nrinv mod 2 = 0 then prim2:=false else begin

divz:=3; m:=trunc(sqrt(nrinv)) ; repeat if nrinv mod divz = 0 then

prim2:=false; divz:=divz+2 until divz > m;

end; if prim2 then writeln(a,b); end; b:=b+1; until b>9; a:=a+1; until a>9; readln end. 13. program nr_naturale; var x,y,z:byte; begin x:=1; repeat y:=1; repeat z:=0; repeat if sqrt(x*10+y*11+z)=int(sqrt(x*10+y+y*10+z)) then write(x,y,z,' '); z:=z+1; until z>9; y:=y+1; until y>9; x:=x+1; until x>9; readln end.


2.3.5. Instrucţiunea FOR Instrucţ iunea for descrie structura repetitivă cu contor. Ea se mai numeşte ciclu cu contor sau instrucţ iune de ciclare cu număr cunoscut de paşi. Este descrisă de următoarea diagramă de sintaxă:

86

instrucţiunea

for

for identificator : Expresie 1 to

downto Expresie 2

doInstrucţiune

Identificator este numele unei variabile simple de tip ordinal, numită contor.Expresie1 ş i expresie2 sunt expresii ordinale, având acelaş i tip cu contorul. Instrucţ iunea reprezintă corpul ciclului. Instrucţ iunea for are formele:I )

for v:=ei to ef do instrucţ iune;

unde: -v este o variabilă numită contor -ei ş i ef sunt expresii ordinale având acelaş i tip cu v -instrucţiune este o instrucţ iune Pascal

Variabila v este iniţ ializată cu valoarea expresiei ei.

Dacă ei are un ordin mai mic decât ef se execută instrucţiune pentru valori crescătoare ale lui v începând cu ei ş i terminând cu ef. Valorile lui v sunt consecutive.

Dacă ei are un ordin mai mare decât ef se trece la instrucţ iunea imediat următoare.

Dacă cele două expresii au aceeaş i valoare, se execută o singură dată instrucţ iunea.

II ) for v:=ei downto ef do

instrucţ iune; unde: -v este o variabilă numită contor -ei ş i ef sunt expresii ordinale având acelaş i tip cu v -instrucţiune este o instrucţ iune Pascal

Variabila v este iniţ ializată cu valoarea expresiei ei.

Dacă ei are un ordin mai mare decât ef se execută instrucţ iune pentru valori descrescătoare ale lui v începând cu ei ş i terminând cu ef. Valorile lui v sunt consecutive.

Dacă ei are un ordin mai mic decât ef se trece la instrucţ iunea imediat următoare.

Dacă cele două expresii au aceeaş i valoare, se execută o singură dată instrucţ iunea.


Problema 1. Se dau două numere naturale a ş i b de forma: a= 2x ş i b= x2 . Pentru toate perechile de numere (a,b) să se determine cel mai mare divizor comun ş i cel mai mic multiplu comun. Rezolvarea problemei: Date de intrare :cele două numere memorate în variabilele a, b. Date de ieşire: cel mai mare divizor comun dat de variabila b ş i cel mai mic multiplu comun Funcţ ia programului: Determină cel mai mare divizor comun al numerelor a ş i b. Pentru aceasta vom folosi algoritmul lui Euclid: Pasul 1:se calculează restul împărţ irii lui a la b Pasul 2: dacă restul este zero atunci cmmdc=b. Altfel se reia pasul 1 pentru noile valori ale lui a ş i b,

respectiv b ş i rest ⎥⎦⎤

⎢⎣⎡ba

.Cel mai mic multiplu comun este câtul dintre produsul numerelor(a ş i b) ş i cel mai

mare divizor comun al lor.

87

DA NU DA NU

Algoritmul în pseudocod: cmmdc_cmmmc înseamnă: început pentru x:=1 până la 9 execută început a:=x*10+2; b:=20+x; p:=a*b; r:=a mod b; cât timp r<>0 execută început a:=b; b:=r; r:=a mod b; sfârşit; scrie('cmmdc al numerelor ',x,'2 si ','2',x,' este ',b,' '); scrie(' cmmmc al numerelor ',x,'2 si ',' 2',x,' este ',p div b,' '); sfârşit; sfârşit.

x:=1 START

Programul Pascal: program cmmdc_cmmmc; var x,a,b,r,p:word; begin for x:=1 to 9 do begin a:=x*10+2; b:=20+x; p:=a*b; r:=a mod b; while r<>0 do begin a:=b; b:=r; r:=a mod b; end; write('cmmdc al numerelor ',x,'2 si ','2',x,' este ',b,' '); writeln(' cmmmc al numerelor ',x,'2 si ',' 2',x,' este ',p div b,' '); end; end.

a:=x*10+2 b:=20+x r:=amodb

r<>0 a:=b

b:=r

r:=amodb

Scrie('cmmdc al nr',x, '2' si '2',x,'este ' ,b,' ')

Scrie('cmmmc al nr',x, '2' si '2',x,'este ' ,pdivb,' ')

x:=x+1 x<,=9

STOP


Problema 2. Aflaţ i perechile de numere naturale de forma 31x ş i 13x prime între ele. Rezolvarea problemei: Date de intrare: nu se introduc date de la tastatură. Date de ieşire: numere naturale de forma 31x ş i 13x prime între ele. Funcţ ia programului: Determină numerele de forma 31x ş i 13x prime între ele. Pentru aceasta se va proceda astfel: -se află cel mai mare divizor comun -dacă cel mai mare divizor comun al celor două numere este 1, atunci numerele sunt prime între ele. START

88

x:=0

NU DA DA NU NU DA

Algoritmul în pseudocod: numere_prime înseamnă: început pentru x:=0 până la 9 execută început a:=103+x*10; b:=301+x*10; repetă r:=a mod b; a:=b; b:=r; până când r=0; dacă a=1 atunci scrie('1',x,'3',' 3',x,'1 '); sfârşit; sfârşit.

Programul Pascal: program numere_prime; var x:byte; a,b,r:word; begin for x:= 0 to 9 do begin a:=103+x*10; b:=301+x*10; repeat r:=a mod b; a:=b; b:=r; until r=0; if a=1 then writeln('1',x,'3',' 3',x,'1 '); end; readln end.

a:=103+x*10

b:=301+x*10

r:=a mod b

a:=b

r=0 b:=r

a=1 Scrie('1',x,'3','3',x,'1')

x:=x+1

STOP x<=9


Problema 3. Ştiind că ş i să se afişeze elementele mulţ imii nA ,...,2,1 { }m,...,2,1=B BbAabaBA ,, . Rezolvarea problemei: Date de intrare: valorile lui m ş i n. Date de ieşire: elementele mulţ imii BbAabaBA ,, Funcţ ia programului: Determină elementele de forma (a,b) unde aєA bєB. Elementele mulţ imii A sunt generate de variabila a, elementele mulţ imii B sunt generate de variabila b. Variabila a primeşte pe rând valorile n1, . Variabila b va memora, pe rând, valorile m1, . Exemplu: A={1,2,3}, B={1,2}.

BA× ={ (1,1), (1,2), (2,1),(2,2),(3,1),(3,2)}. START

89

DA NU NU DA

Algoritmul în pseudocod: Produs_cartezian(n,m) înseamnă: Început

scrie ('n='); citeşte (n); scrie ('m='); citeşte (m); pentru a:=1 până la n execută pentru b:=1 până la m execută scrie(' (',a,',',b,') '); sfârşit.

Programul Pascal: program prod_cart; var a,b,n,m:integer; begin write('n=');readln(n); write('m=');readln(m); for a:=1 to n do for b:=1 to m do writeln(' (',a,',',b,') '); readln end.

Scrie a,b

Citeşte n

a:=1

a<=n

b:=1

b<=m

b:=b+1

a:=a+1

STOP

Citeşte m


Problema 4.

Determinaţ i numerele de forma x= ab care verifică condiţ ia ax Rezolvarea problemei: Date de intrare: nu se introduc date de la tastatură.

Date de ieşire: numerele de forma x= ab care verifică condiţ ia ax

Funcţia programului: Determină valorile lui a şi b pentru care numerele de forma x= ab verifică condiţ ia ax

Valorile posibile ale lui a sunt 9,1 , iar ale lui b sunt 9,0 . Condiţia este verificată dacă atunci când extragem radicalul numărul

obţinut are partea zecimală nulă. Dacă condiţia este verificată se afişează numerele. START

90

DA NU DA NU

Algoritmul în pseudocod: Numere înseamnă: Pentru a:=1 până la 9 execută pentru b:=0 până la 9 execută început x:=a*10+b; if sqrt(x+sqrt(a))=int(sqrt(x+sqrt(a))) then scrie(x,' '); sfârşit; sfârşit.

a:=1

program numere; var x,a,b:byte; b:=0 begin for a:=1 to 9 do for b:=0 to 9 do x:=a*10+b begin x:=a*10+b; if sqrt(x+sqrt(a))=int(sqrt(x+sqrt(a))) then

int(sqrt(x+sqrt(a))=

Scrie x sqrt(x+sqrt(a))

write(x,' '); end; b:=b+1 readln end.

DA

NU

a:=a+1 b<=9

a<=9

STOP


Problema 5.Să se determine fracţ i i le de forma yxxy1

ireductibile.

Rezolvarea problemei:

Date de intrare: nu se introduc date de la tastatură. Date de ieşire: fracţiile de forma yxxy1

ireductibile.

Funcţia programului: Determină valorile lui x şi y pentru care fracţiile de

forma

91

START Scrie('Fracţiile ireductibile sunt')

x:=0 y:=1

a:=100+x*10+y

b:=y*10+x

x:=a mod b

a:=b

b:=r r=0

a=1 Scrie('1',x,y,'/',

y,x, )

y:=y+1

y<=9

x:=x+1 x<=9

STOP

NU

DA

NU

DA

NU

DA

NU

DA

yxxy1

sunt ireductibile. Valorile posibile ale lui x sunt 9,0 , iar ale

lui y sunt xy19,1 . Pentru ca fracţiile să fie ireductibile trebuie ca

yxş i să fie prime între ele.

Algoritmul în pseudocod: fracţii_ired înseamnă: început scrie('Fracţiile ireductibile sunt:'); pentru x:=0 până la 9 execută pentru y:=1 până la 9 execută început a:=100+x*10+y; b:=y*10+x; repetă r:=a mod b; a:=b; b:=r; până când r=0; dacă a=1 atunci scrie('1',x,y,'/',y,x,';') sfârşit; sfârşit.

Programul pascal: program fracţii_ired; var x,y:byte; a,b,r:word; begin write('Fractiile ireductibile sunt:'); for x:=0 to 9 do for y:=1 to 9 do begin a:=100+x*10+y; b:=y*10+x; repeat r:=a mod b; a:=b; b:=r; until r=0; if a=1 then write('1',x,y,'/',y,x,';') end; readln end.



1. Calculaţ i:

a) S=2 4 +4 +…+(2n)4 4

b) P=1*(-3)*5*(-7)* … *( (2n-1)) ±

c) S=)1+n3(*)2-n3(

1+...+

7*41

+4•1

1

d) S= 1+ 2n

1...23

122

1+++

2. Să se calculeze media semestrială la matematică a unui elev. Formula pentru

calcularea mediei semestriale este 4

3 TMO, unde

MO este media aritmetică a notelor de la oral, iar T este nota de la teză.

3. Af işaţ i f racţ iile de forma cdba

43

care se

simplif ică cu 12.

4. Determinaţ i numerele de forma 2abc (a,b,c diferite ) divizibile cu 4, unde ab este un pătrat perfect.

5. Să se determine numerele de forma yx27 care dau restul 5 prin împărţ irea la 12.

6. Să se determine numerele naturale de trei

cif re xyz cu proprietatea că 22234

zyx este un

număr natural.

7. Să se determine toate numerele de forma yx4 care împărţ ite la 15 să dea restul 12.

8. Determinaţ i numerele de forma ba2 care sunt pătrate perfecte.

9. Af laţ i x,yєN astfel încât x 2 +y 2 =832 şi cel mai mare divizor comun al numerelor x şi y este 8.

10. Af laţ i x şi y astfel încât numerele x5 şi y2 să f ie prime între ele.

11. Se introduc de la tastatură n numere întregi. Să se calculeze suma numerelor negative.

12. Să se determine cif rele x şi y astfel încât Nyx21 .

13. Să se determine toate triunghiurile isoscele diferite care au perimetrul p(nr.întreg).

92


93

REZOLVAREA PROBLEMELOR 1a) 1. a) program suma; var i,n:integer; s:longint; begin write('n='); readln(n); s:=0; for i:=1 to n do s:=s+sqr(sqr(2*i)); write('Suma este=',s); readln end. b) program f1b; var i,p,semn,n:integer; begin write('n='); readln(n); p:=1; semn:=1; for i:=1 to n do begin p:=p*semn*(2*i-1); semn:=-semn; end; write('Produsul este ',p); readln end. c) program suma; var i,n:integer; s:real; begin write('n='); readln(n); s:=0; for i:=1 to n do s:=s+1/((3*i-2)*(3*i+1));

write('Suma este=',s:6:2); readln end. d) program suma; var i,n:integer; s:real; begin write('n='); readln(n); s:=0; for i:=1 to n do s:=s+1/sqr(i); writeln('Suma este ',s:6:2); readln end. 2. program media; var i,s,nr,n,t:integer; mo,ms:real; begin s:=0; write('Introduceti numarul de note pe care le are elevul in oral:'); readln (n); for i:=1 to n do begin write('Introduceti nota nr. ', i , ' din oral: '); readln(nr); s:=s+nr; end; mo:=s/n; writeln('Media notelor oral:',mo:6:3); write('Introduceti nota de la teză:'); readln(t); ms:=(3*mo+t)/4; write('Media semestriala este:',ms:6:3); readln end.


94

3. program fracţii; var a,b,c,d:byte; begin for a:=1 to 9 do for b:=0 to 9 do for d:=1 to 9 do for c:=0 to 9 do if((d*100+40+c)mod 12=0) and((a*100+30+b) mod 12 =0) then write(a,'3',b,'/',d,'4',c,' '); end. 4. program div_4; var a,b,c:byte; begin for a:=1 to 9 do for b:=0 to 9 do for c:=0 to 9 do if ((a<>b) and (b<>c))and((c*10+2) mod 4=0)and (sqrt(a*10+b)=int(sqrt(a*10+b))) then write(' ',a,b,c,'2',' '); end. 5. program numere; var x,y:byte; begin for x:=0 to 9 do for y:=0 to 9 do if((7020+x*100+y)mod 12=5) then write(' ','7',x,'2',y,' '); end. 6. program nr_nat;

var x,y,z:byte; begin for x:=1 to 5 do for y:=0 to 5 do for z:=0 to 5 do if (34 /(sqr(x)+sqr(y)+sqr(z)))=int(34 /(sqr(x)+sqr(y)+sqr(z))) then write(' ',x,' ',y,' ',z,' '); end.

7. program numere; var x,y:byte; begin for x:=1 to 9 do for y:=0 to 9 do if (x*100+40+y) mod 15=12 then write(' ',x,'4',y,' '); readln end. 8. program nr_perfecte; var a,b,c:byte; begin for a:=1 to 9 do for b:=0 to 9 do if sqrt(a*100+20+b)=int(sqrt(a*100+20+b) ) then write(' ',a,'2',b,' ') end. 9. program cmmdc; var a,b,r,deimp,imp:word; begin for a:=1 to 28 do begin for b:=1 to 28 do begin i f (sqr(a)+sqr(b))=832 then begin


95

deimp:=a; imp:=b; repeat r:=deimp mod imp; deimp:=imp; imp:=r; unti l r=0; i f deimp=8 then writeln(a:2, ' ' ,b:2) ; end; end; end; readln end. 10. program numere; var x,y:byte; a,b,r:word; begin write('Numerele prime între ele sunt:'); for x:=0 to 9 do for y:=0 to 9 do begin a:=50+x; b:=20+y; repeat r:=a mod b; a:=b; b:=r; until r=0; if a=1 then write(x, ' si’,y,';') end; readln end. 11. program nr_neg; var nr,s,i,n:integer; begin write('n='); readln(n); s:=0;

for i:=1 to n do begin write('nr='); readln(nr); if nr<0 then s:=s+nr; end; write('Suma este',s); readln; end. 12. program numere; var x,y:byte; begin for x:=0 to 9 do for y:=0 to 9 do if sqrt(1020+x*100+y)=int(sqrt(1020+x*100+y)) then write(' x=',x,' y=',y,'; '); readln end. 13. program tr_isoscel; var a,b,p,c,t:integer; begin write('p='); readln(p); t:=p-3; for a:=1 to t do begin c:=p-2*a; b:=a; if c>0 then writeln(a:4,b:4,c:4); end; readln end.

Culegere de probleme Structura repetitivă 2.3.7. TESTE WHILE TEST 1

T1.1.Identificaţi erorile din următoarul program care trebuie să calculeze produsul 1*2*3: a)var p:byte; begin p:=1;i:=1; while i<=3 do; begin p:=p*i; i:=i+1; end; write(p) end. T1.2.Ce va tipări următoarea secvenţă de program?

96

T1.3.Ce modificări trebuie aduse următorului fragment de program pentru a calcula suma primelor n numere impare(s=1+3+…+2n-1)?

i:=1; s:=0; readln(n); while i <=n do

s:=s+(2*i-1); i:=i+1;

writeln(s); a) suma trebuia iniţializată cu 0; b) instrucţiunile s:=s+(2*i-1); i:=i+1; trebuie încadrate de begin şi end; c) contorul i trebuie mărit cu 2 unităţi: i:=i+2. T1.4.Introduceţi şi executaţi următorul program. Stabiliţi funcţia sa.

i) x:=3; y:=25; while x<y do x:=x+5; Writeln(x,’ ‘,y); a)3 25 b)23 25 c)28 25

ii) s:=0; i:=7; while i<=5 do s:=s+i; writeln(s);

a)5 b)0 c)7

iii) p:=1;

program numere; var s,n,r:byte; begin

write(‘n=’); readln(n); s:=0; while n<>0 do begin

r:=n mod 10; semn:=-1; i:=1; while i<=3 do begin p:=p*semn*i; semn:=-semn; i:=i+1; end; write(p); a)3 b)6 c)-6

s:=s+r; n:=n div 10;

end; write(s);

end. T 1.5. Să se afişeze divizorii impari ai unui număr citit de la tastatură.


TEST 2

97

T2.1.Se consideră următoarea secvenţă de program: while m<>n do if m>n then m:=m-n else n:=n-m; writeln(m); Ce valoare se va afişa pentru m=12 ş n=18. T.2.2.Care dintre următoarele secvenţe de program calculează suma: s:=1+ 10...2 ++ . T.2.3. Ce modificări trebuie aduse secvenţei de program de mai jos pentru a calcula produsul primelor 5 numere întregi pozitive?

n:=1; while n <= 5 do; begin

p:=p*n; n:=n+1

end; writeln(p);

T2.4. Introduceţi şi executaţi următorul program. Stabiliţi funcţia sa. Program exemplu; Var i,n:integer; begin Write(‘n=’);

b)s:=1; i:=2; while i<=10 do begin s:=s+sqrt(i); i:=i+1; end;

c)s:=1; a)s:=0; i:=1; while i<=10 do begin s:=s+sqrt(i); i:=i+1; end;

readln(n); i:=2 while i<=10 do begin s:=s+sqr(i);

i:=1; while i<=n div 2 do begin if n mod i=0 then write(i:4); i:=i+1;

i:=i+1; end

end; ; write(n:4);

end. T 2.5. Se citesc de la tastatură n numere reale. Să se se determine minimul acestor numere.


2.3.8. TESTE REPEAT TEST 1T1.1.Identificaţi erorile sintactice din următoarele secvenţe de instrucţiuni: a) m:=5;

98

Repeat m:=m+5; Until m:=100; b) p:=1; writeln(‘Puterile numarului 2:’); repeat p:=p*2; writeln(p); write(‘Continuati? (Y/N):’); readln(c); until c=N or c=n ; T1.2. Ce vor tipari următoarele fragmente de program ? i) a:=0; repeat a:=a+2; until a>10; Writeln (a); a)8 b)10 c)12 ii) a:=0;b:=100; repeat a:=a+5; until a>b; Writeln (a); a)5 b)100 c)105

T1.3. Pentru a calcula a5 – numărul a la puterea 5 – folosim următoarea secvenţă:

a) p:=1; i:=0; repeat p:=p*i; i:=i+1; until i<5; write

b)p:=1; i:=1;

repeat p:=p*a; i:=i+1; until i>5; write

c)p:=1; i:=1;

repeat p:=p*a; i:=i+1; until a<5; write(p); (p); (p);

T.1.4. Ce modificări trebuie aduse secvenţei de program de mai jos pentru a calcula media aritmetică a primelor n numere naturale? program media_aritmetică; var i,n,m_a:integer; begin write('n=');readln(n); m_a:=0; i:=0; repeat m_a:=m_a+i; i:=i+1; until i>n; write('Media aritmetică este ',m_a/n:5:2); end. T1.5. Să se determine toate numerele prime formate din două cifre.


99

TEST 2

T 2.1. Ce va tipări următoarea secvenţă de program pentru n=3? c) readln(n); i:=1;s:=0; repeat s:=s+i; i:=i+1; until i<n; writeln (s); a) 1 b) n*(n+1)/2 c) Nu se poate calcula suma. T 2.2. Ce va afişa următoarea secvenţă de program? program expresie; var i,n,e,a:integer; begin write('n=');readln(n);

e:=0; for i:=1 to n do begin

writeln(‘a=’); readln(a); e:=e+a;

end; write(e); end. a) suma primelor n numere naturale; b) suma a n numere întregi citite de la tastatură; c) media aritmetică a primelor n numere naturale.

T2.3. Ce modificări trebuie aduse următorului fragment de program pentru a afişa cifrele numărului întreg n? write(‘n=’); readln(n); repeat

r:=n mod 10; write(r,’ ’);

n:=n div 10; until n<>0; a) Instrucţiunea write(r,’ ’); trebuie înlocuită cu write(n,’ ’); b) Instrucţiunea n:=n div 10; trebuie înlocuită cu n:=n/10; c) Condiţia n<>0 trebuie înlocuită cu r<>0; d) Condiţia n<>0 trebuie înlocuită cu n=0. T 2.4. Fie următoarea secvenţă de program: s:=0; i:=1; while i<n do begin s:=s+i; i:=i+1; end; Transcrieţi această secvenţă folosind în locul instrucţiunii while instrucţiunile for, respectiv repeat. T 2.5. Să se afişeze produsul primelor n numere pare.

Culegere de probleme Structura repetitivă 2.3.9. TESTE FOR

TEST 1 T1.1.Identificaţi erorile sintactice din următoarele programe:

100

a)var i:byte; begin for i=0 to 9 then write(i:3); end. T1.2.Ce va tipări următoarea secvenţă de program? i) a:=5; s:=0; For i:=1 to a do s:=s+i; Writeln(s); a) 0 b)15 c)6 ii) s:=0;

for i:=5 to 7 do s:=s+i; writeln(s);

a) 5 b)18 c)7

T1.3.Care dintre următoarele secvenţe de program calculează suma:

s:=1 +2 +…+100 . 2 2 2

b)var p,i:real; begin p:=1; for i:=1 to 5 do p:=p+1/i; writeln(p); end.

a)s:=0; for i:=1 downto 100 do s:=s+i*i; b)s:=1; for i:=2 to 100 do s:=s+sqr(i); c)s:=0; for i:=100 to 1 do s:=s+sqrt(i); T1.4.Introduceţi şi executaţi următorul program.Stabiliţi funcţia sa. program numere; var x,y:integer; begin

for x:=0 to 9 do for y:=0 to 9 do

write('2',x,y,'3 '); end. T1.5. Să se afişeze valoarea următoarei expresii: S=1*2 + 2*3 + … + n*(n+1)

Culegere de probleme Structura repetitivă TEST 2 T2.1. Care din următoarele cicluri conţin erori sintactice ? a)For i:=0 to 9 do s:=s+i; b) For i:=0.1 to 0.9 do write(i,’ ’); c)readln(n); prim:=true; program expresie;

var i,n,e,a:integer; begin write('n=');readln(n);

For i:=1 to sqrt(n) do If n mod i=0 then prim:=false; If prim=true then writeln(‘Numarul este prim’); T2.2. Ce va tipări următoarea secvenţă? i) s:=0; for i:=1 to 5 do; s:=s+i; Writeln(s); a) 0; b)5; c)15. ii) p:=1; semn:=1;

for i:=2 to 4 do begin

p:=p*semn*i; semn:=-semn; end; writeln(p);

end; a)2 b)24 c)-24 T2.3. Ce va afişa următorul program?

e:=0; for i:=1 to n do begin

writeln(‘a=’); readln(a);

e:=e+a; end; write(e); end. a) suma primelor n numere naturale; b) suma a n numere întregi citite de la tastatură; c) media aritmetică a primelor n numere naturale. T 2.5.Să se determine numerele de forma y2x si x2y care sunt prime între ele.

101


102

RĂSPUNSURITeste WHILE T 1.1. – variabila i nu a fost declarată;

- după cuvântul cheie do nu se scrie “;”. T 1.2. c) ; b); b).T 1.3. b). T 1.4. Programul calculează suma cifrelor unui număr. T 1.5. program divizori_impari; var n,d,dp:word; begin write('Nr. este:');readln(n); if n>1 then begin writeln(‘Divizorii impari sunt:1’); dp:=n div 2; d:=3; while d<= dp do begin if n mod d=0 then write(d:4); d:=d+2; end; if n mod 2 =1 then write(n:4); end; end. T 2.1. Se va afişa cel mai mare divizor comun al numerelor m şi n: 6. T 2.2. a), b). T 2.3. Produsul trebuie iniţializat cu 1, iar după cuvântul cheie do se elimină “;”.T 2.4. Afişează divizorii numărului n. T 2.5. Program minim; var nr,i:byte; a,min:real; begin write('nr='); readln(nr); write('a='); readln(a); min:=a; i:=2; while i<=nr do begin write('a='); readln(a);

if a<min then min:=a; i:=i+1; end; write('Minimul este: ',min:5:2 ); readln end. Teste REPEAT T 1.1. a) m:=100 trebuie să fie condiţie, deci în locul operatorului “:=” vom avea operatorul “=”. b) N şi n sunt constante de tip caracter, deci trebuie încadrate de apostrofuri. Pentru evaluarea corectă a condiţiei, aceasta trebuia scrisă astfel: (c=’N’) or (c=’n’) T 1.2. i) –c); ii) -c). T 1.3. b) T 1.4. - variabila m_a trebuie declarată de tip real; - contorul i trebuie incrementat în ciclul repeat: i:=i+1. T1.5. program numere; var a,b,n,k:integer; prim:boolean; begin a:=1; repeat b:=0; repeat

n:=a*10+b; k:=2; prim:=true; repeat if n mod k=0 then begin prim:=false; k:=n; end else k:=k+1;


103

until k>trunc(sqrt(n)); if prim then write(a,b,' '); b:=b+1; until b>9; a:=a+1; until a>9; readln end. T 2.1. a). T 2.2. b). T 2.3. d). T 2.4. s:=0; s:=0; i:=1; for i:=1 to n-1 do repeat s:=s+i; s:=s+i; i:=i+1; until i=n; T 2.5. program produs; var n,a,p:word; begin write('n=');readln(n); p:=1; a:=1; repeat

p:=p*2*a; a:=a+1; until a>n;

write(p) end.

Teste FOR T 1.1. a) La iniţializarea contorului în ciclul for se scrie :=, nu egal (=). În ciclul for trebuie scris cuvântul cheie do, nu then. Corect este: for i:=0 to 9 do b) contorul ciclului for, i, este de tip întreg, nu real.

T 1.2. i)- b); ii) -b). T 1.3. b) T 1.4. Afişează numerele de 4 cifre, cu cifra miilor 2 şi cifra unităţilor 3. T 1.5. program expresie; var i,n,s:integer; begin write('n='); readln(n); s:=0; for i:=1 to n do s:=s+i*(i+1); write('Expresia este=',s); end. T 2.1. b) Prima şi ultima valoare a indicelui din ciclul for trebuie să fie de tip ordinal şi nu real. c) funcţia sqrt(n) returnează o valoare de tip real care nu este un tip ordinal. T 2.2. i)-c); ii)-c). T 2.3. b). T 2.4. program nr_prime; var x,y:byte; a,b,r:word; begin write('Numerele prime între ele sunt:'); for x:=1 to 9 do for y:=1 to 9 do begin a:=x*100+20+y; b:=y*100+20+x; repeat r:=a mod b; a:=b; b:=r; until r=0; if a=1 then write(x,’2’,y,' ',y,’2’,x,' ') end; readln end.

Culegere de probleme Tipul tablou

Capitolul 3.

TIPUL TABLOU

3.1. Tablouri unidimensionale - vectori.

Descrierea tipului tablou. Rezolvarea a 9 probleme ce utilizează acest tip. Se analizează problemele, sedescriu algoritmii ce rezolvă problemele şi se scriu programele Pascal ce transcriu algoritmii respectivi. Se propun spre rezolvare 4 teste ce cuprind exerciţii de tip grilă şi dezbaterea unor probleme. Se propune scrierea unor programe Pascal care să rezolve problemele date.

3.2. Tablouri bidimensionale - matrici.

Rezolvarea a 8 probleme ce utilizează acest tip. Se analizează problemele, se descriu algoritmii cerezolvă problemele şi se scriu programele Pascal ce transcriu algoritmii respectivi. Se propun spre rezolvare 3 teste ce cuprind exerciţii de tip grilă şi dezbaterea unor probleme. Se propune scrierea unor programe Pascal care să rezolve problemele date.

104

Culegere de probleme Tipul tablou - Vectori

105

3.1. TABLOURI UNIDIMENSIONALE - VECTORI Tipul tablou este un tip de date structurat, ce conţine o mulţime finită de elemente de acelaşi tip.

Elementele unui tablou sunt ordonate după unul sau mai mulţi indici.

In funcţie de numărul de indici tablourile se clasifică în :

♦ tablouri unidimensionale (ce conţin doar un indice) numite şi vectori;

♦ tablouri multidimensionale (ce conţin mai mulţi indici)

♦ tablouri bidimensionale (ce conţin doi indici) numite şi matrici;

♦ tablouri tridimensionale (ce conţin 3 indici) etc.

Specificarea tipului tablou se face sub următoarea formă:

ARRAY[tip1 , tip2 , …, tipn] OF tip_bază;

unde: ♦ tip1, tip2, …, tipn - reprezintă tipul indicilor. Tipul indicilor este un tip ordinal. Nu se accepta tipul integer, longint etc., ci subdomenii

ale acestora. ♦ tip_bază - reprezintă tipul elementelor tabloului şi poate fi orice tip simplu sau structurat.

De obicei pentru declararea indicilor se foloseşte tipul interval (subdomeniu).

Exemple:

type

vector1=array[1..20] of integer; { vector cu 20 elemente întregi, cu indici întregi } vector2=array['A'.. 'G'] of real; { vector cu 7 elemente reale, cu indici de tip caracter – literele A, B, …, G } matrice=array[1..10,1..10] of char; { matrice cu 100 elemente de tip caracter(10 elemente pe linie x10 elemente pe coloană)

cu indici întregi }


106

Problema 1. Se citeşte un vector cu n elemente întregi. Să se afişeze elementele vectorului. Rezolvarea problemei: Date de intrare: n - numărul elementelor vectorului, a[i] 1≤i≤n, elementele vectorului. Date de ieşire: a[i] 1≤i≤n, elementele vectorului. Fucţia programului: Pentru citirea vectorului a se parcurg două etape: - citirea dimensiunii vectorului - instrucţiunea readln(n); - citirea celor n elemente ale vectorului în prima instrucţiune for: for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end;

Contorul i din ciclul for va indica poziţia elementului citit în vector – astfel pentru i=1 se citeşte elementul a[1]…pentru i=n se citeşte ultimul element, a[n]. Afişarea vectorului realizează scrierea pe ecran element cu element prin a doua instrucţiune for: for i:=1 to n do write(a[i],‘ ’);

Citire dimensiune: n=3 Citire vector

Execuţie for (1): Pas 1: i:=1; Citeşte a[1]: 4 Pas 2: i:=2; Citeşte a[2]: 3

Pas 3: i:=3; Citeşte a[3]: 2 Afişare vector

Execuţie for (2): Pas 1: i:=1; Afişează a[1]: 4 Pas 2: i:=2; Afişează a[2]: 3

Pas 3: i:=3; Afişează a[3]: 2

Algoritmul în pseudocod: Citire_afişare înseamnă: Început Citeşte(n); Pentru i:= 1 la n execută Citeşte(a[i]); Pentru i:= 1 la n execută Scrie(a[i]) Sfârşit.

Programul Pascal: program citire_afisare_vector; var i,n:integer; a:array[1..20] of integer; begin write('Nr. de elemente, n=');readln(n); writeln('Dati elementele vectorului'); for i:=1 to n do begin write('a[',i,']=');

readln(a[i]); end; for i:=1 to n do write(a[ i ],‘ ’); end.

Problema 2. Calculul sumei elementelor unui vector de n numere reale. Rezolvarea problemei: Date de intrare: n - numărul elementelor vectorului, a[i] 1≤i≤n, elementele vectorului. Date de ieşire: s - suma elementelor vectorului. Funcţia programului: Determinarea sumei elementelor din vector. Variabila s se iniţializează cu 0, iar în cadrul ciclului for la această variabilă se adaugă pe rând elementele vectorului for i:=1 to n do s:=s+a[i];


107

n : 3 a : (4,2,5) Iniţializare: s:=0 Execuţie for: Pas 1: i:=1; s:=s+a[1]=0+4=4 Pas 2: i:=2; s:=s+a[2]=4+2=7 Pas 3: i:=3; s:=s+a[3]=7+5=12 s : 12 Algoritmul în pseudocod: Suma înseamnă: Început

Citeşte(n); Pentru i:= 1 la n execută Citeşte(a[i]); s:=0; Pentru i:= 1 la n execută s:=s+ a[i]; Scrie(s) Sfârşit. Programul Pascal: program suma; var i,n:integer;

a:array[1..20] of real; s:real;

begin write('Nr. de elemente, n='); readln(n); writeln('Dati elementele vectorului'); for i:=1 to n do begin write('a[',i,']=');

readln(a[i]); end; s:=0; for i:=1 to n do

s:=s+a[i]; writeln(‘Suma este: ’,s:7:2); end.

Problema 3. Se citeşte un vector a cu n numere naturale. Sa se afişeze elementele pare aflate pe poziţii impare. Rezolvarea problemei: Date de intrare: n - numărul elementelor vectorului, a[i] 1≤i≤n, elementele vectorului. Date de ieşire: a[i] – elementele cu proprietatea dată. Funcţia programului: Se parcurge vectorul cu ajutorul ciclului for; dacă sunt îndeplinite simultan condiţiile: a[i] mod 2=0 – elementul a[i] este par; i mod 2=1 - elementul a[i] este pe poziţie impară, se afişează elementul a[i]. Obs. a) Condiţiile trebie să fie îndeplinite simultan, deci se foloseşte operatorul AND pentru compunerea celor două condiţii

b) Dacă parantezele ar lipsi din condiţia (A[i] mod 2=0) and (i mod 2=1), s-ar efectua mai întâi operaţia a AND a[i], pentru că operatorul multiplicativ AND este prioritar faţă de operatorul de relaţie “=”.


108

n : 3 a : (3,2,6) Execuţie for: Pas 1: i:=1; a[1]=3, (a[1] mod 2=0) (False) ,

(i mod 2=1) (True) Pas 2: i:=2; a[2]=2, (a[2] mod 2=0) (True),

(i mod 2=1) (False) Pas 3: i:=3; a[3]=6, (a[3] mod 2=0) (True),

(i mod 2=1) (True) – sunt îndeplinite ambele condiţii, deci se afişează al treilea element, 6.

Algoritmul în pseudocod: Început Citeşte(n); Pentru i:= 1 la n execută Citeşte(a[i]); Pentru i:= 1 la n execută Dacă (a[i] mod 2=0) and (i mod 2=1) atunci Scrie(a[i]) Sfârşit

Programul Pascal: program elemente_pare; var i,n:byte; a:array[1..20] of word; begin write('Nr. de elemente, n=');readln(n); Writeln('Daţi elementele vectorului'); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; writeln('Elementele pare sunt: '); for i:=1 to n do if (A[i] mod 2=0) and (i mod 2=1)

then write(a[i],' ' ); end.

Problema 4. Se citeşte un şir de numere întregi. Să se afişeze elementele care sunt numere prime si poziţiile acestora în vector. Rezolvarea problemei: Date de intrare: n - dimensiunea vectorului; a[i] 1≤i≤n, elementele vectorului. Date de ieşire: a[i] - numerele prime din vector; i - poziţia elementului prim a[i]. Funcţia programului: Parcurgerea vectorului se realizează în ciclul for de contor i.

Pentru fiecare element a[i] al vectorului se caută divizorii săi - numerele cuprinse între 2 şi trunc(sqrt(a[i])) – în cadrul ciclului for de contor k. Se presupune la început că fiecare număr a[i] este prim - prim:=TRUE - şi dacă se găseşte un divizor propriu al său variabila prim ia valoarea FALSE, indicând ca numărul nu este prim. Obs. Dacă se renunţa la funcţia trunc, variabila sqrt(a[i]) va fi număr real, ceea ce va determina eroare de sintaxă în instrucţiunea for. n : 3 a : (2 , 6 , 11) Execuţie for (contor i):


109

Pas 1: i:=1; a[1]=2; prim:=TRUE În ciclul for de contor k nu se execută

nici un pas deoarece 2>trunc(sqrt(2)).

Pas 2: a[2]=6; prim:=TRUE Execuţie for (contor k): trunc(sqrt(a[3]))=2 Pas 2.1: k=2;

Avem condiţia: a[2] mod k=0 (T) ⇒ prim:=FALSE – deci a[2] nu e prim

Pas 3: a[3]=11; prim:=TRUE Execuţie for (contor k):trunc(sqrt(a[3]))=3 Pas 3.1: k=2;

Condiţia: a[2] mod k=0 este falsă

Pas 3.2: k=3; Condiţia: a[3] mod k=0

este falsă

Condiţia prim=TRUE este adevărată, deci se afişează elementul 11 aflat pe poziţia 3.

Algoritmul în pseudocod: Prime înseamnă: Început Citeşte(n); Pentru i:= 1 la n execută Citeşte(a[i]); Pentru i:= 1 la n execută început prim:=TRUE; Pentru k:=2 la trunc(sqrt(a[i])) execută Dacă a[i] mod k=0 atunci prim:=FALSE; Dacă prim:=TRUE atunci Scrie(a[i],i);

sfârşit Sfârşit.

Programul Pascal: program prime; var a:array[1..20] of integer; k,i,n,m:integer; prim:boolean; begin write('n=');readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; for i:=1 to n do begin prim:=true; for k:=2 to trunc(sqrt(a[i])) do if a[i] mod k=0 then prim:=false; if prim then writeln(a[i],' pe pozitia ',i); end; end.

Problema 5. Se dă un vector de n numere reale. Să se determine elementul minim din vector. Rezolvarea problemei: Date de intrare: n, a[1], a[2], a[3], … , a[n] Date de ieşire: min - elementul minim din vector Funcţia programului: Determinarea elementului minim din vector se realizează astfel: - se iniţializează variabila min cu primul element din vector, a[1]; - se parcurge vectorul începând cu elementul al doilea. Dacă un element a[i] al vectorului este mai mic decât min – deci condiţia

a[i]<min e adevărată- atunci variabilei min i se atribuie valoarea acelui element - min:=a[i]. Vectorul este parcus în totalitate în momentul în care se termină ciclul for; în acest moment variabila min este egală cu valoarea

elementului minim din vector. Elementele vectorului sunt reale, deci variabila min va fi de tip real. n : 3 a : (4 , 2 , 5)

Iniţializare: min:=4 Execuţie for:

Pas 1: i:=2; cond. a[2]<min (T) ⇒ min:=a[2]=2


110

Pas 2: i:=3; cond. a[3]<min (F), min rămâne neschimbat

Se afişează minimul din vector: 2. Algoritmul în pseudocod: Minim înseamnă: Început Citeşte(n);

Pentru i:= 1 la n execută Citeşte(a[i]);

min:=a[1]; Pentru i:= 2 la n execută Dacă a[i]<min atunci min:= a[i] Scrie(min); Sfârşit. Programul Pascal:

program Minim; var a: vector=array[1..20] of real; n,i:integer; min:real; begin write('n='); readln(n); for i:=1 to n do begin write(’a[’,i,’]=’);

readln(a[i]); end; min:=a[1]; for i:=2 to n do if a[i]<min then min:=a[i]; writeln(‘Minimul este ’, min:6:2); end.

Problema 6. Se dă un vector de n numere întregi. Să se ordoneze crescător elementele vectorului. Rezolvarea problemei: Date de intrare: n, a[n] Date de ieşire: vectorul ordonat a[n] Funcţia programului: Vectorul a este ordonat dacă elementele sale îndeplinesc condiţia: a[1]≤a[2]≤…≤a[n]. În acest program se foloseşte metoda bulelor pentru ordonarea elementelor vectorului. Prin această metodă se parcurge vectorul element cu element şi se efectuează interschimbări ale elementelor învecinate până când vectorul devine ordonat.

Înaintea fiecărei parcurgeri presupunem că vectorul este ordonat – variabila ordonat ia valoarea True. La o parcurgerea a vectorului se compară elementele învecinate, a[i] şi a[i+1]. Dacă nu respectă condiţia de ordonare, aceste elemente

se interschimbă şi variabila ordonat ia valoarea false (vectorul nu este încă ordonat). Dacă la sfârşitul unei parcurgeri nu s-a efectuat nici o interschimbare, variabila ordonat rămâne la valoarea true, deci vectorul este

ordonat şi prelucrarea lui se opreşte. Interschimbarea elementelor a[i] şi a[i+1] se realizează cu ajutorul variabilei auxiliare t, care reţine elementul a[i] pentru ca valoarea

acestuia să nu fie ştearsă prin atribuirea a[i]:=a[i+1].

n : 3 a : (7,8,6) Execuţie repeat:

Iteraţie 1: ordonat=TRUE Execuţie for:

Iteraţie 1.1: i=1; cond a[1] > a[2] (F),


111

vectorul rămâne neschimbat Iteraţie 1.2: i=2; cond a[2] > a[3] (T) ⇒

ordonat:=FALSE Vectorul a : ( 7 , 8 , 6 ) devine

a : ( 7 , 6 , 8 ) cond. ordonat=TRUE (F) ⇒ Iteraţie 2: ordonat=TRUE

Execuţie for: Iteraţie 2.1: i=1; cond a[1] > a[2] (T) ⇒

ordonat=FALSE Vectorul a : ( 7 , 6 , 8 ) devine

a : ( 6 , 7 , 8 ) Iteraţie 2.2: i=2; cond a[2] > a[3] (F), cond. ordonat=TRUE (F) ⇒ Iteraţie 3: ordonat=TRUE Execuţie for:

Iteraţie 3.1: i=1; cond a[1] > a[2] (F), vectorul rămâne neschimbat

Iteraţie 3.2: i=2; cond a[2] > a[3] (F), vectorul rămâne neschimbat

cond. ordonat=TRUE (T) ⇒ Vectorul este ordonat, deci nu se vor

efectua interschimbări. Variabila ordonat rămâne neschimbată - la valoarea FALSE; astfel condiţia ordonat=TRUE este adevărată, fapt

care determină ieşirea din ciclul repeat şi afişarea în continuare a vectorului ordonat. Algoritmul în pseudocod: Început Citeşte(n); Pentru i:= 1 la n execută Citeşte(a[i]); Repetă ordonat:=TRUE;

Pentru i:= 1 la n-1 execută Dacă a[i]>a[i+1] atunci început

ordonat:=FALSE; t:= a[i]; a[i]:=a[i+1]; a[i+1]:=t sfîrşit;

Până când ordonat=TRUE; Pentru i:= 1 la n execută Scrie(a[i]); Sfârşit. Programul Pascal: Program Ordonare_vector; var a:array[1..20] of integer; n,i,t:integer;

ordonat:boolean; begin write('n='); readln(n); for i:=1 to n do readln(a[i]); repeat ordonat:=TRUE; {Parcurgerea vectorului} for i:=1 to (n-1) do begin if a[i]>a[i+1] then begin ordonat:=FALSE; {Vectorul

nu este ordonat} {Interschimbarea elementelor}

t:=a[i]; a[i]:=a[i+1]; a[i+1]:=t;

end ; end ; until ordonat=TRUE; for i:=1 to n do write(a[i],' '); end.

Problema 7. Se citesc de la tastatură un vector de dimensiune n şi un număr întreg x. Să se determine dacă numărul x se gaseşte printre elementele vectorului. Rezolvarea problemei: Date de intrare: x - numărul întreg; n - dimensiunea vectorului; a[i] 1≤i≤n, elementele vectorului. Date de ieşire: Un mesaj care indică existenţa sau inexistenţa numărului în vector. Funcţia programului: Se foloseşte metoda de căutare secvenţială, care constă în parcurgerea vectorului până când este găsit numărul dat sau se ajunge la sfârşitul vectorului.


112

Iniţial se presupune că numărul x nu se găseşte în vector (gasit:=FALSE). Dacă un element a[i] al vectorului este egal cu numărul x, variabilă booleană găsit ia valoarea TRUE şi în acest caz se va afişa mesajul 'Nr. este in şir'.

n : 2, x: 3 a : (3 , 5) Iniţializare: găsit:=FALSE Execuţie for: Pas 1: i:=1; cond. a[1]=x (T) ⇒ găsit:=TRUE Pas 2: i:=2; cond. a[2]=x (F) Cond. găsit=TRUE (T) ⇒ Se afişează mesajul : 'Nr. este în vector' DI: n : 2; x: 6 a : (5,4) Iniţializare: găsit:=FALSE Execuţie for: Pas 1: i:=1; cond. a[1]=x (F) Pas 2: i:=2; cond. a[2]=x (F) Variabila găsit a rămas la valoarea iniţială, FALSE, deci se afişează mesajul : 'Nr. nu este în vector'

Algoritmul în pseudocod: Căutare_secvenţială înseamnă: Început Citeşte(x, n); Pentru i:= 1 la n execută Citeşte(a[i]); găsit:=false; Pentru i:= 1 la n execută Dacă a[i]=x atunci găsit:=TRUE; Dacă găsit=TRUE atunci

Scrie('Nr. este în şir') altfel

Scrie('Nr. nu este în şir') Sfârşit.

Programul Pascal: Program Cautare_secvenţială; var x,n,i:integer; a:array[1..100] of integer; gasit:boolean; begin write('Nr. căutat ');readln(x); write('n=');readln(n); găsit:=false; for i:=1 to n do readln(a[i]); for i:=1 to n do if a[i]=x then găsit:=true; if găsit=true then

writeln('Nr. este în sir') else

writeln('Nr. nu este în sir'); end.

Problema 8. Se citesc un vector de n elemente şi un număr natural k, aflat în intervalul [1..n] . Să se realizeze eliminarea elementului aflat pe poziţia k în vector. Rezolvarea problemei: Date de intrare: n, a[1], a[2], … , a[n]; k – poziţia elementului care se elimină. Date de ieşire: vectorul a de dimensiune n-1 obţinut prin eliminarea elementului dat. Funcţia programului: Citirea poziţiei k a elementului care se elimină se reia până când numărul k se găseşte în intervalul valid [1..n] - instrucţiunea repeat.

Elementele a[1], a[2], …, a[k-1] rămân pe poziţiile iniţiale. Elementul a[k] va fi eliminat, prin deplasarea elementelor a[k+1], a[k+2], …,a[n] cu o poziţie spre stânga. Această deplasare se

realizează prin ciclul: for i:=k to n-1 do a[i]:=a[i+1]; prin care peste elementul a[i] se scrie valoarea elementului succesor, a[i+1], începând cu elementul de indice k din vector. Aceste operaţii sunt reprezentate în schema, unde numerele (1), (2), …(n-k+1) reprezintă ordinea operaţiilor:


(1) (2) (n-k) (n-k+1)

a[k-1]a[1] a[2] . . a[k] a[k+1] a[n]a[n-1]. .

n=5; a=(7,4,3,8,9) k=3 Execuţie for: Pas.1 i:=3, a[3]:=a[4]=8

Vectorul devine a=(7,4,8,8,9) Pas.2 i:=4, a[3]:=a[4]=8;

Vectorul devine a=(7,4,8,9,9) n=n-1=4 a:(7,4,8,9)

Algoritmul în pseudocod: Elimină_element înseamnă: Început Citeşte(n); Pentru i:= 1 la n execută Citeşte(a[i]); Repetă

Citeşte(k) Până când(k>0) and (k<=n) Pentru i:= k la n-1 execută a[i]:=a[i+1]; n:=n-1; Pentru i:=1 la n execută Scrie(a[i]) Sfârşit.

Programul Pascal: program elimin_element; var a:array[1..20] of integer; k,i,n:integer; begin

write(‘n=');readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end;

write('Daţi poziţia elem care se elimină:'); repeat readln(k); until(k>0)and(k<=n); for i:=k to n-1 do a[i]:=a[i+1]; {Deplasarea elementelor} n:=n-1; {Dimensiunea vectorului scade

cu o unitate} writeln('Noul vector este'); for i:=1 to n do write(a[i],' '); end.

113


114

Problema 9. Se citeşte un număr întreg pozitiv. Să se afişeze cifrele numărului. Rezolvarea problemei: Date de intrare: n - numărul pozitiv. Date de ieşire: cifre - vectorul de dimensiune k care conţine cifrele lui n. Funcţia programului: Cifrele numărului se determină prin împărţiri repetate la 10. O cifră a numărului este dată de restul împărţirii numărului la 10, rest care se memorează în vectorul cifre. Câtul reprezintă noul număr asupra căruia îi vom aplica în continuare împărţirile la10. Astfel primul rest va fi cifra unităţilor, al doilea rest, cifra zecilor etc. Împărţirile se termină în momentul în care câtul devine 0: c=0 - condiţia din instrucţiunea repeat. Obs.: 1. Dacă se introduce o secvenţă se cifre care începe cu 0, zerourile din faţă se vor elimina automat prin condiţia instrucţiunii repeat.

2.Varibila k reţine în final numărul de cifre ale numărului şi dimensiunea vectorului cifre. Cifrele numărului sunt memorate în vector ordine inversă, deci vectorul va fi afişat cu opţiunea downto a instrucţiunii for.

n : 34 Iniţializare: k:=0 Execuţie repeat: Pas 1: r:=34 mod 10=4

k:=k+1=1; cifre[1]:=4 cifra unităţilor

c:=34 div 10=3 n:=c=3

cond. c=0 (F) ⇒ Pas 1: r:=3 mod 10=3 k:=k+1=2; cifre[2]:=3 cifra

zecilor c:=3 div 10=0 n:=c=0

cond. c=0 (T) - se încheie parcurgerea

ciclului repeat Se afişează vectorul cifre în ordine inversă: 3 , 4

Algoritmul în pseudocod: Cifre_număr înseamnă: Început Citeşte(n); k:=0; repetă r:=n mod 10; k:=k+1;

cifre[k]:=r; c:=n div 10; n:=c; până când c=0; Pentru i:=k la 1 execută Scrie(cifre[i]) Sfârşit.

Programul Pascal: program cifre_număr; var cifre:array[1..20] of byte; i,k,c,n,r:integer; begin write('Daţi numărul'); readln(n); k:=0; repeat r:=n mod 10; {Determinarea

ultimei cifre} {Memorarea cifrei în vector } k:=k+1; cifre[k]:=r; c:=n div 10; n:=c; {Reactualizarea numarului} until c=0; writeln('Cifrele numărului sunt:'); for i:=k downto 1 do write(cifre[i],' '); end.


115

3.1.1. TESTE TEST 1 T1.1. Indicaţi care din următoarele declaraţii de vectori sunt incorecte: a) a:array[1..10] of char; b) a:array[-5,5] of real; c) a:array[20] of integer; T1.2. Indicaţi care din următoarele secvenţe reprezintă citirea elementelor unui vector: a) for i:=1 to n do write('A[',i,']='); readln(A[i]); b) for i:=1 to n do readln('A[',i,']=',A[i]); c) for i:=1 to n do begin write('A[',i,']= '); read(A[i]); end;

T1.3. Ce afişează următoarea secvenţa de program? for i:=1 to n do if (a[i] mod 2)=0 and (i mod 2)=1 then Writeln('Elementul are proprietatea cerută'); a) Elementele divizibile cu 2 aflate pe poziţii impare; b) Elementele divizibile cu 2 aflate pe poziţii pare; c) Elementele pare sau elementele aflate pe poziţii impare. T1.4. Se citesc doi vectori de aceeaşi dimensiune. Următorul fragment de program: p:=1; s:=0;

for i:=1 to n do begin s:= x[i]+ y[i]; p:=p*s; end;

writeln(p); va tipări valoarea expresiei: a) E=(x1+y1)×(x2+y2)×… (xn+yn) b) E=x1×y1+ x2×y2+… xn×yn

T1.5 Se dă un vector de n elemente reale. Să se realizeze eliminarea elementului al 3-lea din vector.


116

TEST 2 T2.1. Care sunt dimensiunile tablourilor următoare? Type a=array[-5..5] of char;

b=array[0..255] of real; c=array[‘A’..’H’] of integer; a) 5 255 8 b)10 256 8 c) 11 256 8 T2.2. Secvenţa următoare de program: verif:=TRUE; for i:=1 to n-1 do

for j:=i+1 to n do if a[i]=a[j] then verif:=FALSE;

If verif then writeln(‘Vectorul are proprietatea cerută’);

testează dacă: a) Elementele vectorului sunt distincte; b) Elementele învecinate ale vectorului sunt distincte; c) Exista un anumit număr în vector,

T2.3. Se consideră următoarele declaraţii: var a:array[1..10] of real; ti,i,j,n:integer; tr:real;

Indicaţi care secvenţă realizează interschimbarea elementelor a[i] şi a[j]: a) a[i]:=a[j]; b) ti:=a[j]; c) tr:=a[i]; a[j]:=a[i]; a[i]:=a[j]; a[i]=ti; a[j]=tr; T2.4. Ce afişează următoarea secvenţa de program? nr:=0; for i:=1 to n do if a[i] >0 then nr:=nr+1; writeln(nr); T2.5. Realizaţi un program care ordonează descrescător elementele unui vector cu elemente reale.


117

TEST 3 T3.1. Se consideră declaraţiile: var i:byte; a:array[1..10] of integer; Care din următoarele atribuiri sunt eronate? a) a[5]:=10/4; b) a[20]:= 8 div 3; c) a[1]:=trunc(sqrt(12));

d) a[4]:=a[3] mod 2; T3.2. Ce proprietate au elementele vectorului a, în cazul în care variabila verif are valoarea TRUE, după executarea următoarei secvenţe de program: i:=1; verif:=TRUE; while (i<=n) and verif do if a[i]-a[i+1]<=0 then i:=i+1 else verif:=FALSE;

a) elementele vectorului sunt negative; b) elementele vectorului sunt în ordine crescătoare; c) elementele vectorului sunt în ordine descrescătoare; Cum se poate rescrie condiţia a[i]-a[i+1]<=0? T3.3. Inserarea unui element x pe poziţia p într-un vector se realizează prin secvenţa: a) for i:=p to n do a[i+1]:=a[i]; a[p]:=x; b) for i:=n downto p do a[i+1]:=a[i];

a[p]:=x; c) for i:=n+1 downto p+1 do a[i]:=a[i-1]; a[p]:=x; T3.4. Se consideră următoarele instrucţiuni: For i:= 1 to n do begin

prim:=TRUE; instrucţiune; if prim then writeln(a[i],‘ este prim’);

end;

Pentru ca grupul de instrucţiuni să realizeze determinarea numerelor prime din vectorul a de dimensiune n, instrucţiune trebuie înlocuită cu:

a) for k:=2 to a[i] do if a[i] div k=0 then prim:=FALSE;

b) for k:=2 to a[i]-1 do if a[i] div k=0 then prim:=FALSE;

c) for k:=2 to sqrt(a[i]) do if a[i] mod k=0 then prim:=FALSE;

d) for k:=2 to trunc(sqrt(a[i])) do if a[i] mod k=0 then prim:=FALSE;

T3.5. Realizaţi programul care afişează numerele prime dintr-un vector.


118

TEST 4 T4.1. Indicaţi care din următoarele declaraţii sunt corecte; a) a:array[’a’..’z’] of byte; b) n:word; a,b:array[1..n] of integer; c) a:integer; a,b:array[1..10] of real; T4.2. Ce erori conţine următorul program care trebuie să calculeze media aritmetică a n numere întregi? Program test; Var i,n:integer; a:array[1..20] of integer; Begin for i:=1 to n do write('a[',i,']=');

readln(a[i]); for i:=1 to n do s:=s+ a[i]; s:=s/n; writeln(‘Media aritmetica este’, s:6:2), End.

T4.3. Care din următoarele instrucţiuni realizează deplasarea elementelor unui vector cu o poziţie spre dreapta? a) for i:=1 to n do a[i]:=a[i+1]; b) for i:=1 to n do a[i+1]:=a[i]; c) for i:=n downto 1 do a[i+1]:=a[i]; d) for i:=n downto 1 do a[i]:=a[i+1]; T4.4. Alegeţi secvenţele de program care realizează inversarea elementelor unui vector: a) for i:=1 to n do begin

t:=x[i]; x[i]:=x[i+1]; x[n+1-i]:=t;

end; b) for i:=n downto 1 do begin

t:=x[i]; x[i]:=x[i+1]; x[n+1-i]:=t;

end; c) for i:=1 to n div 2 do begin

t:=x[i]; x[i]:=x[n+1-i]; x[n+1-i]:=t;

end; T4.5. Realizaţ i programul care determină maximul ş i minimul dintr-un vector de 10 numere întregi.



1. Se citeşte un vector "a" de elemente întregi. Sa se af işeze numerele din vector:

a) divizibile cu 7; b) divizibile cu 3 si cu 5; c) divizibile cu 7 sau cu 11; d) numere divizibile cu un număr k dat.

2. Se dă un vector de numere întregi. Să se determine elementele vectorului, şi poziţ iile aacestora, care au următoarele proprietăţ i:

a) sunt numere impare. b) sunt numere perfecte – numerele care sunt egale cu

suma divizorilor lor. c) Elementele vectorului care sunt pătrate ale unor

numere . 3. Să se af işeze valorile expresiilor:

a) E:= a12+a22+ … +an2 b) E:= (a1+a2+ … +an) × ( b1+b2+ … +bn) c) E:= a1×bn+ a2×bn=1+ … +an×b1

d) E:= ab

ab

... +1

1

2

2+ +

ab

n

n

119

unde a şi b sunt vectori cu n elemente întregi, citiţi de la tastatură.

4.Într-un vector sunt reţ inute valorile produselor achiziţ ionate de un magazin pe timp de o lună – elementul a[ i] reprezintă valoarea totală, la cumpărare, a produsului cu numărul de ordine i. Presupunând că la vânzare se percepe un comision unic de 20%, să se determine diferenţa dintre valoarea totală la vânzare şi valoarea la cumpărare a produselor.

5 Se dă un vector de n elemente. Să se realizeze eliminarea:

a) primului element; b) unui element x citit de la tastatură, în cazul în care

acesta există în vector. 6. La un examen de admitere elevii au fost supuşi

unei probe eliminatorii. Notele obţ inute de elevi sunt citite într-un vector de dimensiune n, unde n reprezintă numărul de candidaţ i. Să se realizeze eliminarea din vector a elevilor nepromovaţ i (cu nota mai mică de 5) şi să se af işeze mediile celor ce vor participa la probele ulterioare.

7. Se dă un vector de n elemente. Să se realizeze inserarea unui element dat:

a) la începutul vectorului;


120

b) la sfârşitul vectoruluc) pe o poziţie dată j.

i;

8. Se da un vector de n elemente. Sa se introducă între f iecare pereche de elemente consecutive din vector media lor aritmetica.

9. Se citesc două mulţ imi, sub forma a doi vectse determine:

ori A ş

ic, se calif ică în se inute de cei doi sp

d naf

vectori ordonaţ i cr

i B. Să

) c) mulţimea C=A \ B (diferenţa mulţimilor A şi B)

10. Se dă un vector de numere înt

a) mulţimea C=A ∪ B (reuniunea mulţimilor A şi B) b) mulţimea C=A ∩ B (intersecţia mulţimilor A şi B

regi. Să se decidă dacă numerele sunt distincte sau nu.

11. Se citesc doi vectori de aceaşi dimensiune n. Să se af işeze vectorul sumă al celor doi vectori.

12. Se dă un vector de n elemente. Sa se determine maximul şi minimul din vector.

13. Se dă un vector de n elemente reale. Să se determine maximul din vector şi poziţ iile în care elementul maxim apare.

14. Într-un vector sunt memorate mediile generale dintr-o clasă cu n elevi. Să se af işeze numărul de ordine al elevilor care au luat premiul I – elevul sau elevii cu media cea mai mare.

15. Se presupune că un magazin a vândut un număr de n produse în f iecare din ultimele două luni (nomenclatorul de produse a rămas acelaşi) . În doi vectori sunt citite numărul de bucăţ i vândute din f iecare produs în cele două luni. Se realizează o situaţ ie totală pe cele două luni a produselor vândute, iar produsul cu cea mai mică vânzare se va elimina din nomenclator. Să se determine numărul de ordine al acestui produs.

16. Se dă un vector de n elemente întregi. Să se verif ice dacă este ordonat crescător.

17. Se dă un vector de n elemente. Să se ordoneze descrescător vectorul.

18. Se consideră semif inalele unui concurs de atletism. Într-un vector sunt memoraţ i timpii pe care i-au obţ inut sportivii participanţ i la o semif inală. Cunoscând că primii doi sportivi, cu timpul cel mai m

mi inală, să se determine timpurile obţfortivi calif icaţ i.

19. Să se memoreze într-un vea) primii 10 multipli ai unui număr dat

ctor: a;.

; c) divizorii primi ai unui număr dat a; b) divizorii unui număr dat a

d) primele n numere prime; e) numerele prime pana la un număr dat m. 20. Se dă un vector de n elemente. Să se genereze

doi vectori astfel încât primul să conţ ină elementele pozitive, iar cel de-al doilea, pe cele negative.

21. Într-un vector sunt memorate mediile la sfârşit e a la o anumită materie dintr-o clasă cu n elevi. Să se işeze numărul de elevi promovaţ i şi numărul elevilor

corige

22. Se citeşte un număr natural n. Să se determine: a) suma cifrelor sale; b) cifra maximă din număr.

nţ i din clasă.

23. Se dă un vector de dimensiune n. Să se af işeze cel mai mare divizor comun al celor n numere.

24. Se citesc de la tastatură doiescător. Să se genereze un nou vector care cuprinde


121

toete elementele celor doi vectori, în ordine crescătoare (problema interclasării a doi vectori).

Într-un vector sunt reţinute sumele solicitate de cei care au obţinut aprobarea pentru împrumut; poziţia în vector este dată de ordinea

25. O bancă acordă împrumuturi subvenţionate, valoarea totală a acestor împrumuturi netrebuind să depăşească o sumă S.

depunerii cererilor. Să se determine câţi solicitanţi vor primi creditul.


122

RĂSPUNSURI T1.1. La punctul b) indicii trebuie despărţiţi prin “..” nu prin “,”. La punctul c) lipseşte a doua limită a intervalului la declararea tipului indicelui. T1.2. c). La punctul a se execută în ciclul for numai instrucţiunea de citire. La puncul b) primul parametru şi al treilea parametru ai instrucţiunii read sunt constanţi, ceea ce nu este permis. T1.3. a). Condiţiile au următoarea semnificaţie: a[i] mod 2 - testează elementele pare; i mod 2 - testează indicii impari. Deoarece apare operatorul logic AND, trebuie îndeplinite amândouă condiţiile simultan, deci punctul c) este exclus. T1.4. a). Expresia este un produs de sume. Se calculează mai întâi suma dintre două elemente, după care se adaugă la produsul total. T1.5 Se aplică algoritmul problemei 8. Modificări: - se declară vectorul a ca având elemente reale; - poziţia k este dată, k=3. program elimin_elementul3; var a:array[1..20] of real; i,n:integer; begin

write('Dimensiunea vectorului:');readln(n);

for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; for i:=3 to n-1 do a[i]:=a[i+1];

n:=n-1; writeln('Noul vector este'); for i:=1 to n do write(a[i]:5:2,' '); end. T2.1. c) T2.2. a). Punctul c) se elimină deoarece testul se efectuează numai asupra elementelor din vector, iar punctul b), deoarece contorii i şi j nu generează elemente învecinate. Punctul a) se poate verifica parcurgând algoritmul pe paşi, considerând doi vectori, unul care respectă concluzia dată, iar celălat nu. T2.3. c) Atribuirea de la punctul a) şterge valoarea elementului a[i]. La punctul b) tipurile variabilei temporale ti nu corespunde cu tipul elementelor vectorului. T2.4. Numărul elementelor pozitive din vectorul a. T2.5. Se aplică algoritmul problemei 5, schimbându-se condiţia a[i]>a[i+1] cu condiţia a[i]<a[i+1]. Program Ordonare_descrescătoare; var a:array[1..20] of integer; n,i,t:integer; ordonat:boolean; begin write('n='); readln(n); for i:=1 to n do readln(a[i]); repeat ordonat:=TRUE; for i:=1 to n-1 do begin if a[i]<a[i+1] then begin ordonat:=FALSE; {Vectorul nu

este ordonat} {Interschimbarea elementelor}


123

t:=a[i]; a[i]:=a[i+1]; a[i+1]:=t;

end ; end ; until ordonat=TRUE; for i:=1 to n do write(a[i],' '); end. T3.1. a),b). La punctul a) se efectuează o împărţire cu rezultatul de tip real, care nu corespunde cu tipul elementelor tabloului. La b) se depăşeşte dimensiunea maximă a vectorului – indicele 20 este mai mare decât dimensiunea declarată, 10. T3.2. b). Condiţia a[i]-a[i+1]<=0 se poate rescrie astfel a[i]<=a[i+1], deci se verifică dacă vectorul este ordonat crescător. T3.3. b). Pentru a insera un element pe o poziţie p trebuie deplasate elementele vectorului cu o poziţie la dreapta, începând cu ultimul element până la elementul a[p], după care se memorează elementul x în poziţia p. T3.4. d) T3.5. Vezi problema 4. T4.1. a). La punctul b) dimensiunea superioară este o variabilă, iar la punctul c) este variabila a este declarată de două ori. T4.2. 1) nu este citită dimensiunea vectorului, n. 2) În primul ciclu for se execută numai instrucţuinea write; pentru a executa şi citirea elementelor vectorului trebuie ca instrucţiunile write şi readln să fie cuprinse între begin şi end. 3) Variabila s trebuie declarată de tip real. T4.3. c). T4.4. c). Secvenţa de la punctul c) schimbă elementele din prima jumătate a vectorului cu cele din a doua

jumătate, în timp ce la primele două puncte această schimbare se face de două ori, revenindu-se la vectorul iniţial. T4.5 Se aplică algoritmul problemei 5, la care se adaugă iniţializarea maximului şi condiţia pentru maxim: a[i]>max: Variabilele max, min şi elementele vectorului vor fi declarate de tip întreg. program Minim_maxim; var i,n, max, min:integer; a:array[1..10] of integer; begin for i:=1 to 10 do begin write('a[',i,']='); readln(a[i]); end; max:=a[1]; min:=a[1]; for i:=2 to 10 do begin if a[i]>max then max:=a[i]; if a[i]<min then min:=a[i]; end; writeln('Maximul este:',max); writeln('Minimul este:',min); end.


124

1.a. Se aplică algoritmul problemei rezolvate 3. Pentru ca un element să fie divizibil cu 7 se verifică condiţia:

a[i] mod 7=0

program divizori; var i,n:integer; a:array[1..20] of integer; begin write('Nr. de elemente, n=');readln(n); writeln('Dati elementele '); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; writeln('Elementele divizibile cu numărul 7 sunt:'); for i:=1 to n do begin if a[i] mod 7=0 then write(a[i],' ') end; readln; end. 1.b. Acelaşi program, însă condiţia subliniată se înlocuieşte cu:

(a[i] mod 3=0) AND (a[i] mod 5=0) Pentru ca numărul să fie divizibil simultan cu 3 şi 5

se foloseşte operatorul conjunctiv AND.

1.c. Acelaşi program, condiţia subliniată se înlocuieşte cu: (a[i] mod 7=0) OR (a[i] mod 11=0)

Operatorul OR semnifică faptul că este de ajuns să fie îndeplinită numai una din condiţiile (a[i] mod 7=0) sau (a[i] mod 11=0) pentru a avea condiţia generală adevărată.

1.d. Programele anterioare se completează cu citirea numărului k, iar condiţia de divizibilitate devine: a[i] mod k=0 program divizibile_k; var i,n,k:integer; a:array[1..20] of integer; begin write('Nr. de elemente, n=');readln(n); write('Daţi numarul:');readln(k); writeln('Daţi elementele '); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; writeln('Elementele divizibile cu ',k,' sunt:'); for i:=1 to n do begin if a[i] mod k=0 then write(a[i],' ') end; readln; end. 2.a. Se aplică algoritmul problemei rezolvate 3. program impare; var i,n:integer; a:array[1..20] of integer; begin write('Nr. de elemente, n=');readln(n); writeln('Daţi elementele '); for i:=1 to n do begin write('a[',i,']=');


125

readln(a[i]); end; writeln('Elementele impare sunt:'); for i:=1 to n do begin if a[i] mod 2=1 then write(a[i],' pe poziţia ',i ) end; end 2.b. Un număr este perfect dacă este egal cu suma divizorilor săi, inclusiv 1. De exemplu, numărul 6 este perfect: 6=1+2+3. Etape: - parcurgerea vectorului;

- iniţializarea sumei s; - Pentru a genera posibilii divizori ai elementului a[i]

se foloseşte instrucţiunea repetitivă for k:=1 to a[i] div 2.

- Dacă variabila k este divizor al lui a[i] - a[i] mod k=0 – atunci k se adaugă la suma divizorilor, s.

- Condiţia ca numărul a[i] să fie perfect este: s=a[i]. program numere_perfecte; var i,n,k,s:integer; a:array[1..20] of integer; begin write('Nr. de elemente, n=');readln(n); writeln('Daţi elementele '); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; writeln('Elementele perfecte sunt'); for i:=1 to n do begin s:=0; {Iniţializarea sumei} for k:=1 to a[i] div 2 do

if a[i] mod k=0 then {Daca a[i] este divizor} s:=s+k; {se adauga la suma} if s=a[i] then write(a[i],' pe pozitia ',i) end; readln; end. 2.c. Prin funcţia sqrt extragem radicalul din fiecare element al vectorului. Dacă rezultatul este un număr întreg, atunci elementul a[i] este pătratul numărului sqrt(a[i]). Pentru a verifica dacă numărul sqrt(a[i]) este întreg, se testează condiţia:

sqrt(a[i])= int(sqrt(a[i])) unde funcţia int extrage partea întreagă a unui număr. program pătrate; var a:array[1..20] of longint; i,n:integer; begin write('n=');readln(n); for i:=1 to n do begin write(‘a[’,i,’]=’);

readln(a[i]); end; writeln(‘Numerele sunt’); for i:=1 to n do begin

if sqrt(a[i])= int(sqrt(a[i])) then write(a[i],’ pe pozitia ‘,i); end; end.


126

3.a. Expresia reprezintă o sumă de pătrate. Pentru fiecare element se realizează ridicarea la pătrat - a[i]*a[i] - după care se adaugă la sumă. program expresie_a; var a:array[1..40] of integer; n,i:integer; s:longint; begin write('n=');readln(n); for i:=1 to n do readln(a[i]); s:=0; for i:=1 to n do s:=s+a[i]*a[i]; write('Valoarea expresiei este: ',s); end.

3.b. Expresia este un produs de sume. Mai întâi se realizează însumarea elementelor celor doi vectori, după care se înmulţesc cele două sume. Ordinea paşilor algoritmului este dată de paranteze şi de ordinea efectuării operaţiilor.

program expresie_b; var a,b:array[1..40] of integer; n,i:integer; s1,s2,e:longint; begin write('n=');readln(n); for i:=1 to n do begin {Citirea primului vector} write('a[',i,']='); readln(a[i]); end; for j:=1 to n do begin {Citirea celui de al doilea vector, de aceeaşi dimensiune cu primul}

write('b[',j,']='); readln (b[j]); end; s1:=0;s2:=0; for i:=1 to n do begin s1:=s1+a[i]; {Suma elementelor primului vector} s2:=s2+b[i]; {Suma elementelor vectorului al doilea} end; e:=s1*s2; write('Valoarea expresiei este: ',e); end. 3.c. Expresia este o sumă de produse. Se observă că suma indicilor unui termen al sumei este n+1, deci termenul general este a[i]*b[n-i+1].

Produsul a[i]*b[n-i+1] se adaugă la variabila s, care va constitui valoarea expresiei. program expresie_c; var a,b:array[1..40] of integer; n,i:integer; s:longint; begin write('n=');readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; for i:=1 to n do begin write('b[',i,']='); readln (b[i]); end; s:=0; for i:=1 to n do


s:=s+a[i]*b[n-i+1]; write('Valoarea expresiei este: ',s); end. 3.d. Expresia este o sumă de fracţii. Pentru ca împărţirile să se poată efectua, se pune condiţia ca elementul b[i] să fie nenul.

Rezultatul împărţirii a[i]/b[i] este un număr real, deci variabila s va fi declarată de tip real.

program expresie_d; var a,b:array[1..40] of integer; n,i:integer; s:real; begin write('n=');readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; for i:=1 to n do begin write('b[',i,']='); readln (b[i]); end; s:=0; for i:=1 to n do if b[i]<>0 then s:=s+a[i]/b[i];

127

a[n-1]a[1] a[2] a[n]. . write('Valoarea expresiei este: ',s:8:2); end. 4. Calculul valorii totale a produselor se realizează în instrucţiunea for subliniată, prin însumarea elementelor vectorului. Diferenţa este dată de cei cele 20% din valoarea totală s:

s:= 0.2*s;

program Diferenţa_valoare; var a:array[1..20] of longint; n,i:integer; s:real; begin write('Numărul de produse:'); readln(n); writeln('Daţi valoarea de cumpărare a produselor '); for i:=1 to n do begin write('Preţul produsului ',i,': '); readln(a[i]); end; s:=0; for i:=1 to n do s:=s+a[i]; s:= 0.2*s; write('Diferenţa dintre valoarea totală de cumpărare si cea de vânzare este: ',s:7:0); end. 5.a. Eliminarea primului element se realizează prin rescrierea elementului a[i] cu valoarea elementului succesor, a[i+1], - for i:=1 to n-1 do a[i]:=a[i+1]; - după schema: (1) (2) (n-1) (n)

unde (1) , (2) ... (n-1), (n) reprezintă

ordinea efectuării operaţiilor.

Astfel primul element va fi şters, iar celelalte se deplasează cu o poziţie spre stânga; dimensiunea vectorului scade cu o unitate.


128

program elimin_1_vector; var a:array[1..20] of integer; i,n:integer; begin write('n=');readln(n); for i:=1 to n do readln(a[i]); for i:=1 to n-1 do a[i]:=a[i+1]; n:=n-1; write('Noul vector este'); for i:=1 to n do write(a[i],' '); end. 5.b. Algoritmul combină căutarea elementului x în vector cu eliminarea acestui element, dacă a fost găsit în vector. Căutarea elementului x se realizează în secţiunea subliniată; dacă a fost găsită valoarea lui x în vector, se reţine poziţia acestuia – k -, iar valoarea găsit ia valoarea TRUE. În acest caz se realizează eliminarea elementului de pe poziţia k, conform algoritmului problemei 8.

program eliminare_x; var a:array[1..20] of integer; k,i,n,x:integer; gasit:boolean; begin write('Dimensiunea vectorului:');readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; write('Daţi elementul care se elimină: '); readln(x); {Căutarea elementului x în vector}

gasit:=FALSE; i:=1;

while not gasit and (i<=n) do begin if x=a[i] then begin gasit:=TRUE; {Elementul a fost găsit} k:=i; {Se reţine poziţia elementului din vector } end; i:=i+1; end; {Eliminarea elementului x, de pe poziţia k} if gasit then begin for i:=k to n-1 do a[i]:=a[i+1]; n:=n-1; writeln('Noul vector este'); for i:=1 to n do write(a[i],' '); end else writeln(‘Elementul ’,x, ‘ nu se află în vector‘); end. 6. Problema se bazează pe algoritmul eliminărilor succesive. Vectorul se parcurge cu instrucţiunea while; dacă este găsit un elev respins – condiţia a[i]<5 – se realizează eliminarea elevului de pe poziţia i, o dată cu scăderea numărului elementelor din vector – n:=n-1 - , iar poziţia în vector pentru care se va realiza testarea va rămâne neschimbată – atribuirile i:=i-1 şi i:=i+1 se anulează. În caz contrar se va trece la următoarea poziţie din vector - i:=i+1.

Obs. Problema se poate extinde prin adăugarea cerinţei ca elevii promovati să fie afişaţi în ordinea mediilor. În acest caz vectorul a nou obţinut va trebui ordonat descrescător.

program proba; var a:array[1..20] of real;


i,j,n:integer; begin write('Daţi numărul de elevi: ');readln(n); for i:=1 to n do begin write('Media elevului ',i,' '); readln(a[i]); end; i:=1; while i<=n do begin if a[i]<5 then begin for j:=i to n-1 do {Eliminarea elementului a[i]} a[j]:=a[j+1]; i:=i-1; n:=n-1; end; i:=i+1; {Trecerea la următorul element} end; writeln('Mediile elevilor promovaţi '); for i:=1 to n do write(a[i],' ');

129

a[n-1]

end. 7.a. Pentru inserarea unui număr pe prima poziţie din vector se parcurg următoarele etape: - deplasarea tuturor elementelor cu o poziţie spre

dreapta, deplasare începută cu ultimul element, pentru a nu se şterge elementele vectorului;

- atribuirea valorii lui x primului element al vectorului.

Dimensiunea vectorului va creşte cu o unitate. program insert_1_vector; var a:array[1..20] of integer;

k,i,n,x:integer; begin write('Dimensiunea vectorului: ');readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; write('Daţi elementul care se inserează: '); readln(x); for i:=n downto 1 do {Deplasarea spre dreapta} a[i+1]:=a[i]; a[1]:=x; {Inserarea numărului x} n:=n+1; writeln('Noul vector este'); for i:=1 to n do write(a[i],' '); end. 7.b. Numărul x se va adăuga pe poziţia n+1, adică după ultimul element al vectorului. program insert_n+1_vector; var a:array[1..20] of integer; k,i,n,x:integer; begin write('Dimensiunea vectorului: ');readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); write('Daţi elementul care se inserează: '); readln(x); a[n+1]:=x; {Inserarea nr. x pe poziţia n+1} n:=n+1; writeln('Noul vector este'); for i:=1 to n do write(a[i],' '); end.

a[1] a[2] a[n]. .

(n) (n-1) (3) (2)


130

7.c. Inserarea elementului x pe poziţia j se realizează astfel: - primele elemente ale vectorului, a[1], a[2], …, a[j-1],

rămân neschimbate. - se deplasează elementele a[j], a[j+1], …, a[n] cu o

poziţie spre dreapta; - se inserează elementul x pe poziţia j.

Instrucţiunea for i:=n downto j do a[i+1]:=a[i]; deplasează elementele a[j]…a[n] cu o poziţie spre dreapta. Astfel se eliberează poziţia j pe care se va copia elementul x. program insert_j_vector; var a:array[1..20] of integer; k,i,n,x:integer; begin write('Dimensiunea vectorului: ');readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; write('Daţi elementul care se inserează: '); readln(x); write('Daţi poziţia pe care se inserează elementul: '); readln(j); for i:=n downto j do {Deplasarea spre dreapta} a[i+1]:=a[i]; a[j]:=x; {Inserarea elementului x} n:=n+1; writeln('Noul vector este'); for i:=1 to n do write(a[i],' '); end.

8. Se calculează media aritmetică, ma, dintre două elemente consecutive a[i] şi a[i+1] pentru 1≤i≤n şi se inserează pe poziţia i+1. Deci în cadrul vectorului se vor adăuga n-1 numere.

Se adaptează algoritmul anterior pentru inserarea a n-1 numere. În ciclul while, care parcurge vectorul, se efectuează următoarele operaţii: - se calculează media aritmetică; - se inserează media aritmetică pe poziţia i+1; - se trece la următorul element al vectorului iniţial; - se măreşte dimensiunea vectorului. Vectorul final va conţine 2*n-1 elemente. program insert_ma_vector; var a:array[1..20] of real; i,j,n,m:integer; ma:real; begin write('Dimensiunea vectorului: ');readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; i:=1; m:=2*n-1; {m - numărul de elemente ale noului vector} while i<m do begin ma:=(a[i]+a[i+1])/2; {Calculul mediei aritmetice} for j:=n downto i do {Deplasarea elementelor} a[j+1]:=a[j]; a[i+1]:=ma; i:=i+2; {Trecerea la următorul element} n:=n+1; end; writeln('Noul vector este'); for i:=1 to m do


write(a[i]:6:2); end. 9.a. Se presupune că elementele citite ale vectorilor a şi b sunt distincte, deoarece vectorii memorează elementele unor mulţimi.

În vectorul c în care se vor memora elementele mulţimii reuniune se copiază toate elemente vectorului a:

for i:=1 to n do c[i]:=a[i]; În continuare în vectorul c se copiază elementele vectorului b care nu se află în a. Se parcurge vectorul b - for j:=1 to m do – şi se compară cu toate elementele vectorului a :

for i:=1 to n do if a[i]=b[j] then comun:=TRUE; Variabila comun are următoarele valori:

.

⎪⎩

⎪⎨⎧

=altfel - FALSE

multime vectorulla deja adaugate elementele dediferit esteb[j]nu elementul daca - TRUE

comun

Dacă se găseşte un element a[i] egal cu elementul b[j] atunci variabila comun ia valoarea TRUE, iar b[j] nu se mai memorează în vectorul c. Dacă nici un element al tabloului a nu este egal cu elementul b[j], atunci variabila comun rămâne la valoarea FALSE, iar b[j] se adaugă în vectorul c. Variabila k reprezintă dimensiunea vectorului reuniune, c. program reuniune; var a,b,c:array[1..40] of integer; m,n,i,j,k,l:integer; comun:boolean;

131begin

write('Nr. de elem ale primei mulţimi '); readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; write('Nr. de elem ale celei de-a doua mulţimi'); readln(m); for j:=1 to m do begin write('b[',j,']='); readln (b[j]); end; for i:=1 to n do {Adăugarea elementelor vectorului a la

vectorul c} c[i]:=a[i]; k:=n; for j:=1 to m do {Parcurgerea vectorului b} begin comun:=FALSE; for i:=1 to n do {Parcurgerea vectorului b} if a[i]=b[j] then comun:=TRUE; {Elementul b[j] se

găseşte in mulţime} if not comun then begin {Dacă elementul nu se găseste in mulţime} k:=k+1; c[k]:=b[j]; {se adaugă noului vector} end; end; write('Reuniunea celor două mulţimi este: '); for i:=1 to k do write(c[i],' '); end. 9.b. Se presupune că elementele citite ale vectorilor a şi b sunt distincte.


132

Fiecare element a[i] fixat prin ciclul for i:=1 to n do se compară cu toate elementele vectorului b. Dacă se găseşte un element b[i] egal cu elementul a[i], atunci elementul a[i] se adaugă în vectorul intersecţie, c:

if a[i]=b[j] then begin k:=k+1; c[k]:=a[i]; end; program intersecţie; var a,b,c:array[1..40] of integer; m,n,i,j,k,l:integer; begin

write('Nr. de elem ale primei mulţimi '); readln(n); write('Nr. de elem ale celei de-a doua

mulţimi'); readln(m); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; for j:=1 to m do begin write('b[',j,']='); readln (b[j]); end; k:=0; for i:=1 to n do {Parcurgerea vectorului a} for j:=1 to m do {Parcurgerea vectorului b} if a[i]=b[j] then {Dacă se găsesc două elemente egale} begin k:=k+1; c[k]:=a[i]; {Se adaugă la vectorul intersecţie} end; write('Intersecţia celor două mulţimi

este:'); for i:=1 to k do write(c[i],' '); end. 9.c. Variabila booleană comun determină egalitatea dintre două elemente ale vectorilor a şi b şi are valorile:

Comun=TRUE dacă avem a[i]=b[j] =FALSE dacă avem a[i]<>b[j]

Fixăm elementul a[i] prin ciclul for i:=1 to n do şi presupunem că acest element nu este egal cu nici un element al tabloului b - comun:=FALSE. Parcurgem în continuare vectorul b şi verificăm dacă elementul a[i] este egal cu un element al vectorului b. Dacă această condiţie este îndeplinită atunci variabila comun ia valoarea TRUE:

for j:=1 to m do if a[i]=b[j] then comun:=TRUE; Dacă pentru nici un element b[j] nu este îndeplinită, condiţia de egalitate, atunci elementul a[i] se adaugă în vectorul diferenţă. program diferenţă var a,b,c:array[1..40] of integer; m,n,i,j,k,l:integer; comun:boolean; begin write('Nr. de elem. ale primei mulţimi '); readln(n); write('Nr. de elem ale celei de-a doua

mulţimi'); readln(m); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; for j:=1 to m do begin write('b[',j,']=');


readln(b[j]); end; k:=0; for i:=1 to n do begin comun:=FALSE; for j:=1 to m do if a[i]=b[j] then comun:=TRUE; if not comun then {Dacă a[i] nu se regăseşte printre elementele vectorului b} begin k:=k+1; c[k]:=a[i]; {Se adaugă la vectorul diferenţă} end; end; write('Diferenţa celor două mulţimi este:'); for i:=1 to k do write(c[i],' '); end. 10. Variabila booleană distinct are valorile: distinct

= ⎩⎨⎧

contrarcaz in FALSEdistincte sunt vectorului elementele dacã TRUE

Presupunem că numerele sunt distincte – distinct:=TRUE. Prin primul ciclu while parcurgem vectorul. Elementul a[i] se compară cu elementele care urmează după el. Dacă două elemente ale vectorului sunt egale - condiţia a[i]=a[j] - atunci variabila distinct ia valoarea FALSE, caz în care elementele vectorului nu sunt distincte. Instrucţiunile while se execută atâta timp cât: - nu s-a ajuns la sfârşitul vectorului – i<=n sau j<=n; - nu s-au găsit două elemente egale – distinct=TRUE.

program elemente_distincte; var i,j,n:integer; distinct:boolean; a:array[1..20]of integer; begin write('n=');readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; i:=1; distinct:=TRUE; while (i<n) and (distinct=TRUE) do {Parcurgerea vectorului} begin j:=i+1; while (j<=n) and (distinct=TRUE) do {Compararea cu

elementele care urmează după elementul curent, a[i]} begin if a[i]=a[j] then {Testăm dacă două elemente sunt egale} distinct:=FALSE; j:=j+1; end; i:=i+1; end; if distinct then writeln('Numerele sunt distincte') else writeln('Numerele nu sunt distincte'); end. 11. const MAX=50; type vector=array[1..MAX] of real; var a,b,s : vector;

133


134

n,i : 1..MAX; begin write('n = ');readln(n); for i:=1 to n do begin write('a[',i,']= '); readln(a[i]) end; for i:=1 to n do begin write('b[',i,']= '); readln(b[i]) end; for i:=1 to n do s[i]:=a[i]+b[i]; writeln('Elementele vectorului suma'); for i:=1 to n do write(s[i]:10:2); readln end. 12. Programul este asemănător cu problema 5, adăugându-se iniţializarea şi condiţia pentru determinarea maximului: a[i]>max. program Minim_maxim; var i,n,max,min:integer; a:array[1..20] of integer; begin write('n=');readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; max:=a[1];

min:=a[1]; for i:=2 to n do begin if a[i]>max then max:=a[i]; if a[i]<min then min:=a[i]; end; writeln('Maximul este:',max); writeln('Minimul este:',min); end. 13. Se observă că într-un vector valoarea maximului poate apare pe mai multe poziţii. Ex. Pentru vectorul a: (4,3,4,1) maximul se găseşte pe poziţiile 1 şi 3. Etapele parcurse sunt următoarele: - se determină maximul din vector, conform algoritmului

anterior; - se compară valoarea max cu toate elementele vectorului. Se

vor afişa toate poziţiile i pentru care este îndeplinită condiţia: a[i]=max.

program Maxim_poz; var i,n:integer; max:real; a:array[1..20] of real; begin write('n=');readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; {Determinarea maximului} max:=a[1]; for i:=2 to n do


135

if a[i]<max then max:=a[i]; write('Maximul este ',max,' si se gaseste pe pozitiile '); {Determinarea poziţiilor în care apare maximul} for i:=1 to n do if a[i]=max then write(i,', '); end. 14. Se aplică algoritmul de la problema anterioară – elementul maxim este reprezentat de media cea mai mare. 15. Vectorul tot conţine totalul bucăţilor vândute pentru fiecare produs vândut în ultimele 2 luni. Variabila min va conţine numărul minim de bucăţi vândute pentru un produs. Se va parcurge vectorul tot şi se compară elementele sale cu valoarea variabilei min; poziţiile elementelor vectorului tot egale cu valoarea variabilei min reprezentând produsele care se elimină din nomenclator. const MAX=100; type vector=array[1..MAX] of word; var l1,l2,tot : vector; n,i : 1..MAX;min : word; begin write('n = ');readln(n); for i:=1 to n do begin write('l1[',i,']= '); readln(l1[i]) end; for i:=1 to n do begin write('l2[',i,']= '); readln(l2[i])

end; for i:=1 to n do tot[i]:=l1[i]+l2[i]; min:=tot[1]; for i:=2 to n do if min>tot[i] then min:=tot[i]; for i:=1 to n do if min=tot[i] then writeln('Se elimină produsul ',i); readln end. 16. Variabila booleană găsit are valorile:

găsit= TRUE – vectorul nu este ordonat crescător = FALSE – vectorul este ordonat crescător

Se parcurge vectorul şi se compară elementele învecinate. Dacă este îndeplinită condiţia a[i]>a[i+1] – elementele a[i] şi a[i+1] nu se găsesc în ordinea cerută – atunci găsit ia valoarea TRUE, deci vectorul nu este ordonat crescător. program verif_ord_vector; type vector=array[1..20] of integer; var a:vector; n,i:integer; gasit:boolean; begin write('n='); readln(n); for i:=1 to n do readln(a[i]); gasit:=FALSE; for i:=1 to (n-1) do begin if a[i]>a[i+1] then gasit:=TRUE; end ; if găsit then writeln('Vectorul nu este ordonat crescător') else writeln('Vectorul este ordonat crescător') end.


136

17. Se aplică algoritmul de la problema rezolvată 5, schimbându-se condiţia de interschimbare a elementelor învecinate - a[i]>a[i+1] - prin condiţia a[i]<a[i+1]. program Ordonare_vector_desc; type vector=array[1..20] of integer; var a:vector; n,i ,t:integer; gasit:boolean; begin write('n='); readln(n); for i:=1 to n do readln(a[i]); gasit:=TRUE; while gasit do begin gasit:=FALSE; for i:=1 to n-1 do begin if a[i]<a[i+1] then begin gasit:=TRUE; t:=a[i]; a[i]:=a[i+1]; a[i+1]:=t; end ; end ; end ; for i:=1 to n do write(a[i],' '); readln; end. 18. Vectorul t va conţine timpii obţinuţi de sportivi. Se sortează în ordine crescătoare elementele vectorului t,

apoi se afişează primele 2 elemente ale sale, care reprezintă timpii primilor 2 sportivi calificaţi. const MAX=100; type vector=array[1..MAX] of word; var t : vector; n,i : 1..MAX;aux : word; sortat : boolean; begin write('n = ');readln(n); for i:=1 to n do begin write('t[',i,']= '); readln(t[i]) end; repeat sortat:=true; for i:=1 to n-1 do if t[i]>t[i+1] then begin aux:=t[i]; t[i]:=t[i+1]; t[i+1]:=aux; sortat:=false end until sortat=true; writeln('Timpii obţinuţi de primii 2 sportivi calificaţi sunt:'); writeln(t[1]); writeln(t[2]); readln end. 19.a. Spre deosebire de majoritatea programelor antrerioare care aveau ca date de intrare elementele unui vector, grupa de probleme 19 au ca date de intrare un număr pe baza căruia se generează vectori cu anumite proprietăţi.


137

În acest caz contorul ciclului for generează atât primele 10 numere naturale cu care trebuie înmulţit numărul a pentru a obţine multiplii cât şi indicii vectorului, deci poziţiile pe care se memorează multiplii. program multipli; var i,a:integer; m:array[1..20]of integer; begin write('a=');readln(a); for i:=1 to 10 do m[i]:=a*i; write('Prumii 10 multipli ai numărului ',a,' sunt:'); for i:=1 to i do write(m[i],' '); end. 19.b. Algoritmul de determinare a divizorilor unui număr este cunoscut. În primul ciclu for, prin variabila i se generează posibilii divizori ai lui a. Dacă i este divizor – este îndeplinită condiţia a mod i=0 – atunci i se va memora în vector pe poziţia k. Se observă că variabilele i şi k nu coincid ca valoare. Variabila i se incrementează automat prin ciclul for, iar variabila k se incrementează numai dacă i este divizor al lui a. Variabila k reţine în final dimensiunea vectorului divizor. program divizori; var k,i,a:integer; divizor:array[1..20]of integer; begin write('a=');readln(a); k:=0; for i:=1 to a div 2 do {Generarea posibililor divizori} if a mod i=0 then {Dacă contorul i este divizor} begin

k:=k+1; divizor[k]:=i; {se adaugă vectorului divizor} end; k:=k+1; divizor[k]:=a; write('Divizorii numărului a sunt:'); for i:=1 to k do write(divizor[i],' '); readln; end. 19.c. Generarea posibililor divizori ai numărului a se realizează la fel ca în programul precedent. În plus, apare secvenţa de determinare a numărului prim, studiată în problema 4. Dacă i este divizor al numărului a se verifică dacă acest număr este prim prin instrucţiunile:

prim:=TRUE; for j:=2 to trunc(sqrt(i)) do if i mod j=0 then prim:=FALSE; if prim then {se adaugă la vectorul divizori} program divizori_primi; var k,i,j,a:integer; prim:boolean; divizor:array[1..20]of integer; begin write('a=');readln(a); k:=0; for i:=2 to a div 2 do if a mod i=0 then {Determinarea unui divizor} begin {Verificăm dacă divizorul este prim} prim:=TRUE; for j:=2 to trunc(sqrt(i)) do if i mod j=0 then prim:=FALSE; if prim then


138

begin k:=k+1;

divizor [k]:=i; end; end;

prim:=TRUE; for j:=2 to trunc(sqrt(a)) do if a mod j=0 then prim:=FALSE; if prim then begin k:=k+1;

divizor [k]:=i; end; if k=0 then {În vectorul divizor nu s-a adăugat nici un număr} writeln('Numărul a nu are divizori ') else begin write('Divizorii primi ai numărului a sunt:'); for i:=1 to k do write(divizor[i],' '); end; end. 19.d. Această problemă face parte din categoria mai largă a generării unui anumit număr de elemente care au o proprietate dată. Se observă că nu putem spune cu exactitate cât va fi al n-lea număr. În acest caz se folosesc două variabile: a – generează posibilele numere prime;

k – numără câte numere prime am găsit. Variabila a generează numerele consecutive începând cu 2. În ciclul while se testează dacă numărul a este prim (analog cu problema anterioară) caz în care a se adaugă la vectorul prime, variabila k crescând cu o unitate. Variabila a se incrementează indiferent dacă valoarea anterioară a fost sau nu număr prim.

Condiţia ciclului while este pusă în funcţie de variabila k, ieşirea din ciclu făcându-se când s-au determinat cele n numere prime (while k<=n do…). program n_numere_prime; var k,n:integer; i,a:longint; prim:boolean; prime:array[1..20]of integer; begin write('n=');readln(n); a:=2;k:=1; while k<=n do {Ciclul while se repetă până când găsim cele n numere} begin prim:=TRUE; for i:=2 to trunc(sqrt(a)) do {Generăm posibilii divizori} if a mod i=0 then {Verificăm dacă numărul a este prim} prim:=FALSE; if prim then {Dacă a este prim} begin prime[k]:=a; {se adaugă în vectorul prime} write(prime[k],' '); k:=k+1; end; a:=a+1; {Se trece la testarea următorului număr} end; end. 19.e. Principiul de rezolvare este acelaşi cu al programului anterior. Singura diferenţă apare la condiţia cilului while, care este în funcţie de variabila a, ieşirea din ciclu făcându-se când s-a determinat ultimul număr prim mai mic decât a - while a<=n do ...


139

program numere_prime; var k,n,i,a:longint; prim:boolean; prime:array[1..20] of longint; begin write('n=');readln(n); a:=2;k:=1; while a<=n do {Ciclul while se repetă până când găsim

numerele prime până la n} begin prim:=TRUE; for i:=2 to trunc(sqrt(a)) do if a mod i=0 then prim:=FALSE; if prim then begin prime[k]:=a; write(prime[k],' '); k:=k+1; end; a:=a+1; end; end. 20. Ca date de intrare avem dimensiunea şi elementele vectorului a. Pe baza acestui vector se generează cei doi vectori: b şi c:

- vectorul b, cu indicele k1, reţine numerele pozitive; - vectorul c, cu indicele k2, reţine numerele

negative. Parcurgerea vectorului a se face cu instrucţiunea for

i:=1 to n do…, deci indicele i al lui a creşte automat. În cadrul ciclului se testează dacă elementul curent

a[i] este pozitiv, caz în care indicele k1 creşte cu o unitate, iar a[i] se adaugă la vectorul b pe poziţia k1.

Dacă a[i] este negativ, se adaugă în vectorul c pe poziţia k2. În final dimensiunea vectorului b este k1, iar a vectorului c,

k2. program nr_pozitive_negative; var i,k1,k2,n:integer; a,b,c:array[1..20]of integer; begin write('n=');readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; for i:=1 to n do begin if a[i]>0 then begin {Numărul a[i] este pozitiv} k1:=k1+1; b[k1]:=a[i]; {şi se adaugă în vectorul b} end else if a[i]<0 then begin {Numărul a[i] este negativ} k2:=k2+1; c[k2]:=a[i]; {şi se adaugă în vectorul c} end; end; writeln('Numerele pozitive sunt:'); for i:=1 to k1 do write(b[i],' '); writeln; writeln('Numerele negative sunt:'); for i:=1 to k2 do write(ci],' '); end.


140

21. Vectorul a conţine mediile celor n elevi. Variabila nr_p reţine numărul elevilor promovaţi, iar nr_c al celor corigenţi. Cele două valori se vor incrementa în funcţie de valoarea de adevăr a condiţiei a[i]>=5 . program nr_promovaţi; var i,nr_p,nr_c,n:integer; a:array[1..30] of real; begin write('n=');readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; nr_p:=0; nr_c:=0; for i:=1 to n do if a[i]>=5 then nr_p:=nr_p+1 else nr_c:=nr_c+1; writeln('Numarul elevilor promovaţi este:',nr_p); writeln('Numărul elevilor corigenţi este:',nr_c); end. 22.a. Programul se bazează pe algoritmul problemei rezolvate nr. 8. În ciclul repeat se detemină pe rând cifrele numărului şi se adaugă la variabila sumă, s. program sumă_cifre_număr; var cifre:array[1..20] of byte; i,k,c,n,r:integer; begin

write('Daţi numărul'); readln(n); k:=0; repeat r:=n mod 10; {Determinarea ultimei cifre} k:=k+1; cifre[k]:=r; {Adăugarea ultimei cifre în vector} c:=n div 10; {c - numărul obţinut prin eliminarea

ultimei cifre} n:=c; until c=0; {Suma elementelor vectorului} for i:=1 to k do s:=s+cifre[i]; writeln(' Suma cifrelor numărului este:',s); end. 22.b. Determinarea cifrei maxime din număr se poate împărţi în două subprobleme:

- determinarea cifrelor unui număr; - afişarea maximului dintr-un şir de numere. Se memorează cifrele în vectorul cifre, de dimensiune k şi se

dermină maximul elementelor vectorului. program cifre_număr; var cifre:array[1..20] of byte; i,k,c,n,r:integer; begin write('Daţi numărul');

readln(n); k:=0; {Determinarea cifrelor} repeat r:=n mod 10; k:=k+1; cifre[k]:=r; c:=n div 10;


141

n:=c; until c=0; {Determinarea maximului} max:=a[1]; for i:=2 to k do if cifre[i]>max then max:=a[i]; writeln(‘Cifra maximă este ’,max); end. 23. Rezolvarea acestei probleme urmăreşte determinarea c.m.m.d.c. dintre mai multe numere, numere memorate în elementele vectorului a. În variabila d1 se determină c.m.m.d.c. al primelor două elemente ale vectorului. În continuare se determină c.m.m.d.c. dintre numărul d1 şi al treilea element al vectorului. Procedeul se repetă până când se parcurge tor vectorul. În acest moment în variabila d1 se obţine c.m.m.d.c. al elementelor vectorului. program cmmdc_vector; var i,d1,d2,r,n:integer; a:array[1..20]of integer; begin write('n=');readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end; d1:=a[1]; for i:=2 to n do begin d2:=a[i];

{Determinarea c.m.d.c. dintre variabila d1 si elementul curent} repeat r:=d1 mod d2; d1:=d2; d2:=r; until r=0; end; writeln('CMMDC este ',d1); end. 24. Elementele vectorilor a şi b trebuie date de la tastatură în ordine crescătoare. Indicii vectorilor sunt următorii:

i – pentru vectorul a; j – pentru vectorul b; k – pentru vectorul c;

Prin ciclul while se parcurg ambii vectori. Dacă un element al vectorului a este mai mic decât un element

al vectorului b, elementul primului vector se adaugă în vectorul c şi se măresc indicii vectorilor a şi c.

Altfel se adaugă în vectorul c elementul corespunzător al vectorului b şi se măresc indicii vectorilor b şi c.

În cazul în care s-a ajuns la sfârşitul unui vector şi din celălalt vector au rămas elemente neparcurse, atunci acestea se vor adăuga vectorului c. Acesta va avea în final n+m elemente care se afişează prin ultima instrucţiune for. program intercl; var a, b, c:array[1..50] of integer; m,n,i,j,k,l:integer; begin write('n='); readln(n); for i:=1 to n do begin write('a[',i,']='); readln(a[i]); end;


142

write('m='); readln(m); for j:=1 to m do begin

write('b[',j,']='); readln (b[j]); end; i:=1; j:=1; k:=0; {Iniţializarea contorilor} while(i<=n) and (j<=m) do {Parcurgem vectorii a şi b până

se ajunge la sfarşitul unuia dintre ei} begin k:=k+1; if a[i]<b[j] then begin c[k]:=a[i]; {Dacă elementul a[i] este mai mic,

acesta este adăugat vectorului c} i:=i+1; {Deplasare la următorul element din

vectorul a} end else begin

c[k]:=b[j]; {Dacă elementul b[j] este mai mic, acesta este adăugat vectorului c}

j:=j+1; {Deplasare la urmatorul element din vectorul b}

end; end; {Adăugarea elementelor rămase dintr-un vector} if i<=n then {Dacă au mai rămas elemente în vectorul a } for l:=i to n do {acestea se adaugă în vectorul c} begin k:=k+1; c[k]:=a[l]; end else {Dacă au mai rămas elemente în vectorul b } for l:=j to m do {acestea se adaugă în vectorul c}

begin k:=k+1; c[k]:=b[l]; end; {Afişarea vectorului c} for i:=1 to k do write('c[',i,']=',c[i]); end. 25. Presupunem că sunt n cereri. Suma totală aprobată pentru aceste cereri se citeşte în variabila s. Elementele vectorului a memorează valoarea fiecărei cereri depuse.

În ciclul while se determină numărul de cereri aprobate astfel: dacă se aprobă cererea cu numărul de ordine i, se scade din valoarea totală s valoarea acelei cererei, a[i].

Ciclul while se repetă atâta timp cât: (k<n) – nu s-au selectat toate cererile – k reţine numărul de ordine al cererii aprobate. (s>0) – se mai pot aproba cereri pentru că suma totală nu s-a epuizat. La sfârşit se afişează numărul total de cereri aprobate - k-1 - şi valoarea acestora. program cereri; type vector=array[1..30] of longint; var a:vector; i,k,n,s:integer; begin writeln('Daţi suma totală'); readln(s); writeln('Daţi numărul de cereri'); readln(n); writeln('Daţi valoarea fiecărui împrumut'); for i:=1 to n do begin


143

Write('Suma ',i,' '); Readln(a[i]); end; k:=1; While (k<=n) and (s>0) do begin s:=s-a[k];

k:=k+1 end; Writeln('S-au aprobat ',k-1,' cereri: '); for i:=1 to k-1 do writeln(' Cererea ',i,' de valoare ',a[i]); end.

Culegere de probleme Tipul tablou - Matrici 3.2. Tablouri bidimensionale - matrici. Problema 1. Se citeşte de la tastatură o matrice cu n linii şi m coloane. Să se determine elementele pare şi poziţiile acestora în matrice. Rezolvarea problemei: Date de intrare: n - numărul de linii; m - numărul de coloane; a[i,j], 1≤ i ≤n, 1≤ j ≤m - elementele matricei Date de ieşire: a[i,j] - elementele pare ale matricei, i - linia, j - coloana pe care se află elementul. Funcţia programului: Iniţial se vor citi dimensiunile matricei, n şi m.

Matricea se citeşte element cu element, cu ajutorul a două cicluri for îmbricate. Contorul i al primului for va reprezinta linia matricei, iar j, coloana acesteia.

Parcurgerea matricei se realizează cu cele două instrucţiuni for îmbricate, etapă în care verificăm dacă elementului actual, a[i,j] este par (a[i,j] mod 2=0).

Dacă este îndeplinită condiţia, se afişează elementul şi poziţia acestuia în matrice (liniile i,j).

Forma generală a unei matrice cu n linii şi m coloane este:

A=

⎟⎟⎟⎟⎟⎟⎟⎟

⎠

⎞

⎜⎜⎜⎜⎜⎜⎜⎜

⎝

⎛

n,mn,jn,n,

i,mi,ji,i,

,m,j,,

,m,j,,

a..........aaa...................................a..a....aa.......................a.......a....aaa.........a..aa

21

21

221212

112111

..................

..

Primul indice i reprezintă linia, iar indicele j, coloana matricei.

Încadrarea intre limite a indicilor i şi j - 1≤ i ≤n, 1≤ j ≤m - se transpune în limbajele de programare prin două cicluri for îmbricate: for i:=1 to n do for j:=1 to m do

Prin primul ciclu for se fixează linia i, iar prin al doilea ciclu, după j, se parcurge linia i. n=2 (2 linii), m=3 (3 coloane)

A= ⎟⎟⎠

⎞⎜⎜⎝

⎛974165

Citirea primei linii - i=1: a[1,1]=5, a[1,2]=6, a[1,3]=2 Citirea liniei a doua - i=2: a[2,1]=4, a[2,2]=7, a[2,3]=9 Parcurgerea matricei Pe prima linie se afişează Elementul 6 cu indicii 1 şi 2 Pe a doua linie se afişează Elementul 4 cu indicii 2 şi 1 Algoritmul în pseudocod: Pare înseamnă: Început Citeşte(n,m); Pentru i:=1 la n executã Pentru j:=1 la m executã Citeşte (a[i,j]); Pentru i:=1 la n executã Pentru j:=1 la m executã dacã a[i,j] mod 2=0 atunci Scrie(a[i,j], i, j); Sfârşit.

Programul Pascal: var a : array[1..20,1..20] of integer; n,m,i,j:integer; begin write('Daţi nr. de linii ');readln(n); write('Daţi nr. de coloane ');readln(m); writeln('Introduceţi elementele matricei'); for i:=1 to n do {Citirea elementelor

matricei} for j:=1 to m do begin write('a[',i,',',j,']='); readln(a[i,j]); end; for i:=1 to n do for j:=1 to m do if a[i,j] mod 2=0 then writeln('Elem ',a[i,j],’ linia ’,i,’

coloana ’,j); end.

144

Culegere de probleme Tipul tablou - Matrici Problema 2. Se dă o matrice cu n linii şi m coloane. Să se afişeze elementele aflate pe ultima coloană. Rezolvarea problemei: Date de intrare: n - numărul de linii; m - numărul de coloane; a[i,j], 1≤ i ≤n, 1≤ j ≤m - elementele matricei. Date de ieşire: a[i,m], 1≤i≤n - elementele de pe ultima coloană. Funcţia programului: Elementele de pe ultima coloană pot fi asociate unui vector de dimensiune n. Indicii acestor elemente se generează astfel:

♦ indicele al doilea, al coloanei, rămâne fixat la valoarea m;

♦ primul indice, al al liniei, este dat de contorul unui ciclu for de forma

for i:=1 to n do write(a[i,m])

n=2, m=3, a= ⎟⎟⎠

⎞⎜⎜⎝

⎛92

7465

se afişează elementele 2

9

Algoritmul în pseudocod: Coloana înseamnă: Început Citeşte(n,m); Pentru i:=1 la n executã Pentru j:=1 la m executã Citeşte(a[i,j])); Pentru i:=1 la n executã Scrie(a[i,m]) Sfârşit.

Programul Pascal: program coloana; var a:array[1..20,1..20] of integer; n,m,i,j:integer; begin write('Dati nr. de linii ');readln(n); write('Dati nr. de coloane ');readln(m); for i:=1 to n do for j:=1 to m do begin write('a[',i,',',j,']='); readln(a[i,j]); end; writeln(Elementele de pe ultima coloană sunt:); for i:=1 to n do

writeln(a[i,m]); end.

Problema 3. Se dă o matrice cu n linii şi m coloane. Să se determine media aritmetică a elementelor de pe o linie dată k. Rezolvarea problemei: Date de intrare: n - numărul de linii; m - numărul de coloane; a[i,j], 1≤ i ≤n, 1≤ j ≤m - elementele matricei; k- numărul de ordine al liniei matricei. Date de ieşire: ma - media aritmetică a elementelor de pe linia k. Funcţia programului: Elementele de pe linia k au forma a[k,j], 1≤j≤m, unde indicele liniei, k, este fixat . Se însumează elementele în ciclul for după j, după care se împarte suma la m - numărul de elemente de pe linia matricei. Obs. Linia unei matrice poate fi asociată unui vector: în matrice se fixează indicele liniei şi se se parcurg elementele de pe acea linie cu un ciclu for al cărui contor generează indicele j al coloanei: For j:=1 to m do Prelucrează a[k,j]

145

Culegere de probleme Tipul tablou - Matrici Algoritmul în pseudocod: Medie_linie înseamnă: Început Citeşte(n,m); Pentru i:=1 la n executã Pentru j:=1 la m executã Citeşte(a[i,j]); Citeşte(k); m_a:=0; Pentru j:=1 la m executã m_a:=m_a+a[k,j]; m_a:=m_a/m; Scrie(m_a) Sfârşit.

Programul Pascal: program medie_linie; var a:array[1..20,1..20] of integer; n,m,k,i,j:integer; m_a:real; {m_a se obţine prin

împărţire reală} begin write('Daţi nr. de linii ');readln(n); write('Daţi nr. de coloane ');readln(m); for i:=1 to n do for j:=1 to m do begin write('a[',i,',',j,']='); readln(a[i,j]);

end; write('Daţi nr. de liniei ');readln(k); m_a:=0; for j:=1 to m do m_a:=m_a+a[k,j]; m_a:=m_a/m; Writeln('Media aritmetică a elem. de pe

linia ',k,' este ',m_a:7:2); end.

Problema 4. Se dă o matrice cu n linii şi m coloane cu elemente reale. Să se detemine maximul elementelor din matrice. Rezolvarea problemei: Date de intrare: n - numărul de linii; m - numărul de coloane; a[i,j], 1≤ i ≤n, 1≤ j ≤m - elementele matricei. Date de ieşire: max - maximul elementelor matricei. Funcţia programului: Variabila max se iniţializează cu valoarea primului element al matricei, a[1,1]. Cu cele două cicluri for îmbricate se parcurge matricea; dacă se găseşte un element a[i,j] mai mare decât max, acesta îşi schimbă valoarea: max:= a[i,j].

n=3, m=2, a= ⎟⎟⎟

⎠

⎞

⎜⎜⎜

⎝

⎛

896876

Iniţializare max=a[1,1]=6 Elementul max îşi schimbă valoarea de 3 ori: max:=a[1,2]=7

max:=a[2,1]=8 max:=a[3,1]=9 – care este maximul elementelor din matrice. Algoritmul în pseudocod: Maxim_matrice înseamnă: Început Citeşte(n,m); Pentru i:=1 la n executã Pentru j:=1 la m executã Citeşte(a[i,j]); max:=a[1,1]; Pentru i:=1 la n executã Pentru j:=1 la m executã Dacã max<a[i,j] atunci max:= a[i,j]; Scrie(max) Sfârşit. Programul Pascal:

program maxim_matrice; var a:array[1..20,1..20] of real; max:real; n,m,i,j:integer; begin write('n=');readln(n); write('m=');readln(m); for i:=1 to n do for j:=1 to m do readln(a[i,j]); max:=a[1,1]; for i:=1 to n do for j:=1 to m do if max<a[i,j] then max:=a[i,j]; write('Elementul maxim este:' , max:5:2); end.

146

Culegere de probleme Tipul tablou - Matrici Problema 5 . Se dau n numere naturale. Sã se genereze o matrice care conţine pe fiecare linie primii 5 multipli ai numerelor. Rezolvarea problemei: Date de intrare: n - numărul de numere naturale. Date de ieşire: a[i,j], 1≤ i ≤n, 1≤ j ≤5 - elementele matricei. Funcţia programului: Pentru două numere date (de exemplu 2 şi 3), matricea va arăta astfel:

2 4 6 8 103 6 9 12 15

⎛⎝⎜

⎞⎠⎟

Numerele citite sunt memorate în elementele primei coloane, elemente de forma a[i,1], 1≤i≤n.

În continuare se parcurge matricea pentru a calcula multipli. Se fixează numărul de pe poziţia i printr-un ciclu for al cărui contor este i. Se parcurge linia i printr-un ciclu for de contor j. Pentru a obţine cel de-al j-lea multiplu, se înmulţeşte numărul iniţial a[i,1] cu j. Obs. Afişarea elementelor unei matrici se realizează parcurgând matricea prin cele două cicluri for şi afişând elementul curent, a[i,j].

Pentru a marca spaţiile dintre elementele unei linii se foloseşte afişarea cu format, iar pentru a trece la o linie nouă, instrucţiunea writeln: for i:=1 to n do begin for j:=1 to 5 do write(a[i,j]:5); writeln; end ; Algoritmul în pseudocod: Multiplii înseamnă: Început Citeşte(n); Pentru i:=1 la n executã Citeşte(a[i,1]); Pentru i:=1 la n executã Pentru j:=2 la 5 executã a[i,j]:=j*a[i,1]; Pentru i:=1 la n executã Pentru j:=2 la 5 executã Scrie(a[i,j]) Sfârşit.

Programul Pascal: program multiplii_matr; var a:array[1..20,1..20] of integer; n,m,i,j:integer; begin write('Daţi nr. de numere ');readln(n); for i:=1 to n do begin write('Numãrul ',i,'); readln(a[i,1]); end; for i:=1 to n do for j:=2 to 5 do a[i,j]:=j*a[i,1]; for i:=1 to n do begin for j:=1 to 5 do write(a[i,j]:5); writeln; end ; end.

Problema 6 . Pentru o matrice pãtraticã datã, sã se afişeze elementele de pe diagonala principalã şi elementele de pe diagonala secundarã. Rezolvarea problemei: Date de intrare: n - numărul de linii şi coloane; a[i,j], 1≤ i,j ≤n, - elementele matricei. Date de ieşire: ai,i,1≤i≤n - elementele de pe diagonala principală; ai,n+1-i,1≤i≤n - elementele de pe diagonala secundară. Funcţia programului: Elementele de pe diagonala principală au proprietatea că indicele de linie este egal cu cel de coloană - i=j. Indicii elementelor de pe diagonala secundară respectă condiţia: i+j=n+1 ⇒ j=n+1-i. Deci aceste elemente sunt de forma ai,n+1-i,1≤i≤n.

147

Culegere de probleme Tipul tablou - Matrici

Din matricea pătratică de dimensiune n dată mai jos: - elementele de pe diagonala principală

a1,1, a2,2 . . . ann

- elementele de pe diagonala secundară a1,n, a2,n-1 . . . an1

A=

a aa a

1,1 1,n

2,2 2,n 1

a ................................aa ................................ a............ ................................ ....... .............

1,2 1,n 1

2,1 2,n

−

−

.... ................................ ....... .....a a ......... ...... ..... ....... ................. ................................ ....... .....

a

i,1 i,2 a a

a

i,n i 1 i,i

n,1

− +

n,2 n,n 1................................a −

⎛

⎝

⎜⎜⎜⎜⎜⎜⎜⎜⎜

⎞

⎠

⎟⎟⎟⎟⎟⎟⎟⎟⎟an,n

Ex: n=3, A= ⎟⎟⎟

⎠

⎞

⎜⎜⎜

⎝

⎛

111012597634

Elementele de pe diagonala principală:

4 9 11 Elementele de pe diagonala secundară: 6 9 12 Algoritmul în pseudocod:

Diagonale înseamnă: Început Citeşte(n,m); Pentru i:=1 la n executã Pentru j:=1 la n executã Citeşte(a[i,j]); Pentru i:=1 la n executã

Scrie(a[i,i]); Pentru i:=1 la n executã

Scrie(a[i,n-i+1]); Sfârşit.

Programul Pascal:

program diagonale; var a:array[1..20,1..20] of integer; n,i,j:integer; begin write('Daţi dimensiunea matricei '); readln(n); for i:=1 to n do for j:=1 to n do readln(a[i,j]); writeln('Elementele de pe diagonala

principală::'); for i:=1 to n do write(a[i,i],' '); writeln; writeln('Elementele de pe diagonala

secundară:'); for i:=1 to n do write(a[i,n-i+1],' '); end.

Problema 7 . Se dau douã matrci cu dimensiuni egale, n,m. Sã se afişeze suma celor douã matrici. Rezolvarea problemei: Date de intrare: n - numărul de linii; m - numărul de coloane; a[i,j], b[i,j], 1≤ i ≤n, 1≤ j ≤m - elementele celor două matrici. Date de ieşire: c[i,j], 1≤ i ≤n, 1≤ j ≤m - elementele matricei sumă. Funcţia programului: Dimensiunile celor două matrice citite trebuie să fie egale.

Însumarea matricilor presupune adunarea elementelor aflate pe aceleaşi poziţii în cele două matrice: c[i,j]:=a[i,j]+b[i,j] pentru 1≤ i ≤n, 1≤ j ≤m.

Deoarece la afişare indicii i, j vor fi generaţi de variabilele contor ele celor douã cicluri for îmbricate, afişarea se realizează în secvenţa de calcul.

148

Culegere de probleme Tipul tablou - Matrici

Pentru două matrice a şi b de dimensiuni n şi m matricea sumă s se obţine însumând elementele cu aceaşi indici din cele două matrice: Cn,m=

⎟⎟⎟⎟⎟⎟⎟⎟

⎠

⎞

⎜⎜⎜⎜⎜⎜⎜⎜

⎝

⎛

++++

+++

+++++

n,mn,mn,jn,jn,n,n,n,

i,mi,mi,ji,ji,i,i,i,

,m,m,j,j,,,,

,m,m,j,j,,,,

ba.....b.....ababa................................................................

ba...+ba....baba..................................................ba......+b.a....bababa.......+b...a..+baba

2211

2211

222212121212

111111211111

......................

..

n=2, m=3,

a= , ⎟⎟⎠

⎞⎜⎜⎝

⎛974265

b= ⎟⎟⎠

⎞⎜⎜⎝

⎛627503

Matricea sumă este

c= ⎟⎟⎠

⎞⎜⎜⎝

⎛15911768

Algoritmul în pseudocod: Suma înseamnă: Început Citeşte(n,m); Pentru i:=1 la n executã Pentru j:=1 la m executã Citeşte(a[i,j]); Pentru i:=1 la n executã Pentru j:=1 la m executã

Citeşte(b[i,j]); Pentru i:=1 la n executã Pentru j:=1 la m executã început c[i,j]:= a[i,j]+b[i,j]; Scrie(c[i,j]) Sfârşit Sfârşit. Programul Pascal: program suma_matrice; var a,b,c:array[1..20,1..20] of integer; n,m,i,j:integer; begin write('Dati nr. de linii ');readln(n);

write('Dati nr. de coloane ');readln(m); writeln('Introduceti elementele primei

matrice'); for i:=1 to n do for j:=1 to m do begin write('a[',i,',',j,']=');

readln(a[i,j]); end; writeln('Introduceti elementele matricei

a doua'); for i:=1 to n do for j:=1 to m do begin write('b[',i,',',j,']=');

readln(b[i,j]); end; writeln('Matricea suma este:'); for i:=1 to n do begin for j:=1 to m do begin c[i,j]:=a[i,j]+b[i,j]; write(c[i,j]:5); end; writeln; end ; end.

Problema 8. Mediile obţinute de elevii unei clase sunt memorate într-o matrice astfel:pe linia i, toate cele m medii ale elevului cu numãrul de ordine i;

♦ pe coloana j, mediile la un anumit obiect a tuturor celor n elevi la toatã clasa. Sã se determine:

a) mediile generale ale elevilor, c) elevii corigenţi; b) elevul (sau elevii) cu cea mai mare medie generală; d) media generalã a clasei.

149

Culegere de probleme Tipul tablou - Matrici Rezolvarea problemei: Date de intrare: n - numărul de elevi; m - numărul de materii; a[i,j], 1≤ i ≤n, 1≤ j ≤m –mediile celor n elevi la materiile date. Date de ieşire:

a) m_e[n] – vector cu n componente care reţine mediile generale ale fiecărui elev;

b) i - numărul de ordine al elevului (elevilor) cu media maximă;

c) i - numărul de ordine al elevilor corigenţi;

d) m_g - media generală a clasei. Funcţia programului: Programul este o combinare a problemelor studiate anterior. Prezentăm ca exemplu matricea asociată pentru trei elevi şi mediile acestora la două materii. materia 1 materia 2

150

98 1

a) Numărul de elemente ale vectorului m_e este egal cu n - numărul liniilor matricei a.

- Ciclul for după i fixează linia matricei, contorul i fiind şi indice pentru vectorul m_e.

- Iniţializarea elementului m_e[i] se face la începutul fiecărei linii,

- calculul mediei se face prin însumarea elementelor de pe linia i: m_e[i]:=m_e[i]+a[i,j]. iar după parcurgerea liniei se împarte m_e[i] la numărul de coloane ale matricei, m.

Pentru exemplul considerat se calculează m_e[1]:=8.5, m_e[2]:=6.5, m_e[3]:=8.5.

b) Pentru determinarea elevilor cu media maximă se parcurg două etape: ♦ Determinarea maximului elementelor din vectorul mediilor, m_e;

♦ Afişarea poziţiilor elevilor care au media maximă prin parcurgerea vectorului şi compararea elementului

curent, m_e[i], cu elementul maxim, max. Se afişează elevii cu numărul de ordine 1 şi 3, care au media 8.5.

c) Pentru un elev cu numărul de ordine i se parcurge linia corespunzătoare şi se determină dacă are medii sub 5 - a[i,j]<5 - caz în care variabila booleană corigent ia valoarea true.

Se afişează elevul cu numărul de ordine 2.

d) Variabila m_g se determină prin însumarea tuturor elementelor matricei, prin formula: m_g:=m_g+a[i,j]. După parcurgerea matricei se împarte variabila m_g la numărul de elemente ale matricei, n*m: m_g:=m_g/(n*m).

În cazul nostru media generală este 7.5.

107 3 elev74 2 elev

elev

Algoritmul în pseudocod: Medii înseamnă: Început Citeşte(n,m); Pentru i:=1 la n executã Pentru j:=1 la m executã Citeşte(a[i,j]); Pentru i:=1 la n executã început

m_e[i]:=0; Pentru j:=1 la m executã

m_e[i]:=m_e[i]+a[i,j]; m_e[i]:= m_e[i]/m; sfârşit;

Pentru i:=1 la n executã Scrie(m_e[i]);

max:=m_e[1]; Pentru i:=2 la n executã

Dacă m_e[i]>max atunci max:=m_e[i]; Pentru i:=1 la n executã Dacă m_e[i]=max atunci Scrie(i); Pentru i:=1 la n executã început corigent:=FALSE;

Pentru j:=1 la m executã Dacă a[i,j]<5 atunci corigent:=TRUE;


151

Dacă corigent=TRUE atunci Scrie(i);

Sfârşit; m_g:=0; Pentru i:=1 la n executã Pentru j:=1 la m executã m_g:= m_g+a[i,j]; m_g:=m_g/(n*m); Scrie(m_g) Sfârşit. Programul Pascal: program medii_clasa; var a:array[1..30,1..30] of real; m_e:array[1..30] of real; n,m,i,j:integer; max,m_g:real; corigent:boolean; begin write('Daţi nr. de elevi ');

readln(n); write('Daţi nr. de materii ');

readln(m); for i:=1 to n do for j:=1 to m do begin

write('a(',i,',',j,')='); readln(a[i,j]); end; {Calculul mediilor pe fiecare linie (pentru fiecare elev în parte)} for i:=1 to n do begin {Alegerea elevului i} m_e[i]:=0; {Iniţializarea mediei pentru

fiecare elev} for j:=1 to m do {Calculul mediilor

elevului i} m_e[i]:=m_e[i]+a[i,j]; m_e[i]:=m_e[i]/m; writeln('Elevul cu numărul de ordine ',i,'

are media ',m_e[i]:4:2); end; {Determinarea elevilor cu media cea mai mare}

max:=m_e[1]; for i:=2 to n do {Determinarea

mediei maxime} if max<m_e[i] then max:=m_e[i]; writeln('Elevii cu media cea mai mare, '

,max:4:2, ' au numarul de ordine '); for i:=1 to n do {Determinarea cu

media maxima} if max=m_e[i] then write(i,' ');

{Determinarea elevilor corigenti} writeln('Elevii corigenţi au

numărul de ordine '); for i:=1 to n do begin corigent:=FALSE; for j:=1 to m do {Se verifică mediile

pentru fiecare elev } if a[i,j]<5 then corigent:=TRUE; if corigent then write(i,' '); end; writeln; {Determinarea mediei generale} m_g:=0; {Iniţializarea mediei

generale} {Parcurgerea matricei} for i:=1 to n do for j:=1 to m do m_g:=m_g+a[i,j]; m_g:=m_g/(n*m); writeln('Media generală a clasei este ',

m_g:4:2); end.

3.2.1. TESTE TEST 1


152

T1.1. Indicaţi care din următoarele declaraţii de matrice sunt corecte:

a) a:array[1..20] of real;

b) b:array[10,10] of integer;

c) c:array[0..10,1..20] of byte;

d) d:array[‘a’..’g’,1..8] of char;

T1.2. Elementele aflate pe prima linie a unei matrice cu m coloane sunt afişate de instrucţiunea:

a) for j:=1 to m do write(a[1,j],’ ’);

b) for j:=1 to m do writeln(a[i,j]);

c) for i:=1 to m do write(a[i,1]);

T1.3. Următoarea secvenţă de program: for i:=1 to n do for j:=1 to m do if a[i,j] <> 0 then writeln('Elementul ',a[i,j]);

afişează a) Elementele diferite de 0 din matrice; b) Poziţiile elementelor nenule din matrice; c) Elementele impare din matrice.

T1.4. Se consideră următorul program: program matrice; const n=3; var a:array[1..20,1..20] of integer; i,j:integer; begin for i:=1 to n do for j:=1 to n do

if i=j then a[i,j]:=1 else a[i,j]:=0;

for i:=1 to n do begin for j:=1 to n do

write(a[i,j],’ ’); writeln; end. Ce valori va afişa programul? T1.5. Să se calculeze maximul şi minimul elementelor din ultima coloană a unei matrice cu elemente întregi.

TEST 2 T2.1. Indicaţi câte elemente au tablourile următoare:


153

a) array[1..5,1..10] of byte; b) array[-2..2,0..5] of byte; c) c:array[‘a’..’g’,1..8] of word; T2.2. Indicaţi care secvenţe realizează citirea şi care realizează afişarea elementelor dintr-o matrice:

a) for i:=1 to n do begin for j:=1 to m do write(a[i,j],’ ’); writeln; end;

b) for i:=1 to n do for j:=1 to m do write('a[',i,',',j,']='); readln(a[i,j]);

c) for i:=1 to n do for j:=1 to m do begin write('a[',i,',',j,']='); readln(a[i,j]); end;

T2.3. Maximul elementelor dintr-o matrice cu n linii şi m coloane este deteminat de următoarea secvenţă de program:

a) max:=a[1,1]; for i:=1 to n do for j:=1 to m do if max>=a[i,j] then max:=a[i,j];

b)max:=a[1,1]; for i:=1 to n do

for j:=1 to n do if max>a[i,j] then max:=a[i,j];

c)max:=a[1,1]; for i:=1 to n do

for j:=1 to m do if max<a[i,j] then max:=a[i,j];

T2.4. Determinaţi funcţia următorului program program matrice; var a:array[1..20,1..20] of integer; n,m,i,j:integer; begin write(n= ');readln(n); write(m= ');readln(m); for i:=1 to n do for j:=1 to m do

readln(a[i,j]); for i:=1 to n do write(a[i,m],' '); end. T2.5. Să se afişeze elementele nenule aflate pe diagonala principală a unei matrice pătratice.


154

TEST 3 T3.1. Indicaţi erorile ce apar în următoarele secvenţe de program:

a) i,j,n,m:integer; a:array[1..n,1..m] of real;

b) var b[1..5,1..10]:integer; c) var i,n:integer;

c:array[1..10,1..10] of integer; begin readln(n); for i:=1 to n do c[i]:=n/2; end. T3.2. Următoarea secvenţă de program: s:=0; for i:=1 to n do for j:=1 to m do begin

s:=s+a[i,j]; writeln('Suma elem. este ',s); determină:

a) Suma elementelor aflate pe linia i; b) Suma elementelor aflate pe coloana j; c) Suma elementelor din matrice;

T3.3. Ce determină executarea următorului program? program diagonale; var a:array[1..20,1..20] of integer; n,i,j:integer;

begin write('Daţi dimensiunea matricei ');readln(n); for i:=1 to n do for j:=1 to n do readln(a[i,j]);

nr:=0 for i:=1 to n do

if a[i,n-i+1] div 2 =0 then nr:=nr+1; writeln(nr);

end. T3.4. Să se corecteze greşelile apărute în următorul program, astfel încât acesta să calculeze suma elementelor de pe ultima coloană a unei matrice pătratice de dimensiune n. program suma_coloana; var a:array[1..20,1..20] of integer; n,i,j:integer; begin write('n=');readln(n);

for i:=1 to n do for j:=1 to m do write('a[',i,',',j,']='); readln(a[i,j]); for j:=1 to n do

s:=s+a[n,j] writeln(Suma elementelor de pe ultima coloanã este:’,s); end. T3.5. Să se afişeze elementele care sunt multipli de 3, aflate pe coloane pare, dintr-o matrice cu n linii şi m coloane.

Culegere de probleme Tipul tablou – Matrici


1. Se citeşte o matrice cu n linii şi m coloane. Sã se afişeze elementele pozitive aflate pe:

ce cu elemente reale, astfel încãt în c toare.

n fiind identificatã printr-un numãr

e i şi j se intersecteazã; ar

ã se determine strada (sau strãzile) cu numãr maxim de intersecţii.

a) coloanã datã de la tastaturã; b) ultima linie.

2. Sã se determine media aritmeticã a elementelor unei matrice cu elemente reale.

3. Fiind datã o matrice şi un numãr întreg sã se determine dacã acel numãr se regãseşte în elementele matricei. in caz afirmativ sã se afişeze poziţiile în care apare.

4. Fiind datã o matrice, sã se adauge dupã ultima linie un vector care conţine suma elementelor de pe fiecare coloanã.

5. Se citesc o matrice, un vector şi un număr care reprezintă numărul unei coloane ale matricei. Să se insereze vectorul în matrice pe locul ocupat de coloana k.

6. Sã se determine minimul de pe fiecare coloană a unei matrice date.7. Fiind dată o matrice, să se afişeze numărul de ordine al fiecarei linii pentru care produsul elementelor acesteia este nenul.

8. Fiind datã o matrice sã se determine linia (liniile) cu cele mai multe elemente pare.

9. Fiind datã o matrice sã se determine linia (liniile) cu cele mai multe elemente care sunt multipli de 5.

10. Interschimbaţi coloanele unei olo a

matricã

e: a) deasupra diagonalei principale;

an k elementele sã fie în ordine cres

11. Să se afişeze elementele aflat

b) sub diagonala principală; c) deasupra diagonalei secunadare; d) sub diagonala secundarã.

12. Sã se genereze o matrice patratica, cu n linii si n coloane, care conţine pe diagonala principalã cifra 1, iar în rest 0.

13. Se considerã mãrul de ea se construieşte astfel:

♦ a[i,j]:=1 dacã elevul cu numãrul de ordine i a primit manualul cu numãrul j; ♦ a[i,j]:=0 în caz contrar .

Sã se adauge matricei un vector de n elemente care conţine numãrul de manuale date la fiecare materi ,

o matrice cu m linii şi m coloane, unde n reprezintã nu copii al unei clase, iar m numãrul de materii ale acelei clase. Matric

e un vector de m elemente care conţine numãrul de manuale luate de fiecare elev şi un numãr aflat pe poziţia n+1,m+1 care conţine numãrul total de manuale date.

14. Î tr-un oraş sunt n strãzi, fiecare stradãde ordine. Se construieşte matricea intersecţiilor astfel:

♦ a[i,j]=1 dacã strãzil♦ a[i,j]=0 în caz contr

S

155


156

a b)

T1.4. Matricea cu cifra 1 pe diagonala principală (condiţia i=j)şi 0 în rest:

⎞⎛010001

.

a:array[1..20,1..20] of integer;

e coloane ');readln(m); entele matricei');

begin e('a(',i,',',j,')=');

]);

ax<a[i,m] then max:=a[i,m]; ];

eln('Maximul este: ',max);

r după,

a trebuie ca i end.

şi b) se determină minimul. e pe ultima coloană, m.

matricei ');readln(n);

begin

if a[i,i]<>0 then write(a[i,j],' ')pe diagonala principala, iar

conditia a[i,i]<>0, elementele nenule}

RĂSPUNSURI T1.1. c), d). La puctul a) este declarat un vector, iar ltrebuie declarate tipuri ordinale pentru specificarea indicilor (Ex. b:array[1..10,1..10] of integer). T1.2. a) La punctul b) elementele de pe linia i, iar la punctul c), elementele de pe coloana 1. T1.3. a) – elementele nenule determinate de condiţia a[i,j] <> 0.

⎟⎠⎝ 100⎟⎟

⎜⎜⎜

T1.5program minim_max_linie; var

n,m,max,min,i,j:integer; begin write('Dati nr. de linii ');readln(n); write('Dati nr. d writeln('Introduceti elem for i:=1 to n do for j:=1 to m do writ readln(a[i,j end; max:=a[1,m]; min:=a[1,m]; for i:=2 to n do begin if m if min>a[i,m] then min:=a[i,m end; writ

writeln('Minimul este: ',min); end. T2.1. Se înmulţesc numărul de elemente de pe linie cu numărul de elemente de pe coloană. a) 5x10=50 b) 5x6=30 c) 7x8=56 T2.2. a) Afişarea c) Citirea. La punctul b) se execută în ciclurile

, iafor numai afişarea poziţiilor elementelor din matricecitirea elementului a[n,m]. Pentru a se realiza citire

două instrucţiuni să fie încadrate de begin şcele T2.3. c). La punctele a)T2.4. Afişează elementele dT 2.5. program diag_nenule; var a:array[1..20,1..20] of integer; n,i,j:integer; begin

a write('Dati dimensiune for i:=1 to n do

1 to n do for j:= write('a(',i,',',j,')=');

); readln(a[i,j] end;

writeln('Elementele nenule de pe diagonala principala:'); for i:=1 to n do

; {a[i,i] - fixeaza elementele de

end. T3.1. a) Marginile superioare - n şi m - ale matricei a sunt variabile. Pentru a aloca matricei un anumit spaţiu de memorie trebuie ca marginile superioare să fie constante. b) După identificatorul matricei trebuie să apară ”:array”, iar


157

în

ce -

e nu to n

ă. entelor se face după ultima linie, nu r fi fost:

m Multipli3_coloane_pare;

f integer;

(n); n(m);

;

{Conditia j mod 2=0determina elementele care se afla pe coloane pare} end.

ainte de tipul elementelor, cuvântul cheie “of”. c) 1)Identificatorul c este declarat ca o matrice de elemente întregi.

2) Selecţia unui element este făcută după un indic[i] - corect fiind selectarea după doi indici.

3) Împărţirea n/2 se efectuează numai asupra numerelor reale, nu şi a celor întregi, aşa cum este declarată variabila n. T3.2. c) pentru că este parcursă întreaga matrice prin cele două cicluri for. T3.3. Numărul elementelor pare aflate pe diagonala secundară. T3.4. – În ciclul for j:=1 to m do apare variabila m cara fost declarată şi nici citită. Corect ar fi fost for j:=1o, a fiind o matrice pătraticd

Însumarea elemcoloană. Corect a for j:=1 to n do s:=s+a[j,n] T3.5.

progravar n,m,i,j:integer; a:array[1..20,1..20] obegin write('n=');readln

m=');readl write(' for i:=1 to n do

for j:=1 to m do begin

write('a[',i,',',j,']='); readln(a[i,j]); end; write('Elementele cu proprietatea ceruta sunt '); for i:=1 to n do for j:=1 to m do if (a[i,j] mod 3=0) AND (j mod 2=0)then write(a[i,j],' '){Conditia a[i,j] mod 3=0 determina elementele care sunt multipli

} de 3


158

1.a) Se aplică un algoritm asemănător celui din problema rezolvată 2. Se parcurge coloana k şi se afişează elementele pozitive de pe această coloană: for i:=1 to n do if a[i,k]>0 then

writeln(a[i,k]);

program afisare_coloana_k; var a:array[1..20,1..20] of integer; n,m,k,i,j:integer; begin write('Dati nr. de linii ');readln(n); write('Dati nr. de coloane ');readln(m); writeln('Introduceti elementele matricei'); for i:=1 to n do for j:=1 to m do begin write('a(',i,',',j,')='); readln(a[i,j]); end; write('Dati numarul coloanei ');readln(k); writeln('Elementele pozitive de pe coloana '

,k,' sunt '); for i:=1 to n do if a[i,k]>0 then

writeln(a[i,k]); end. 1.b) Se parcurge linia n şi se testează dacă elementul curent a[n,j] este pozitiv: for j:=1 to m do if a[n,j]>0 then write(a[n,j],' '); program afisare_ultima_linie; var

a:array[1..20,1..20] of integer; n,m,i,j:integer; begin write('Dati nr. de linii ');readln(n); write('Dati nr. de coloane ');readln(m); writeln('Introduceti elementele

matricei'); for i:=1 to n do for j:=1 to m do begin write('a(',i,',',j,')='); readln(a[i,j]); end; writeln('Elementele pozitive de pe ultima linie:'); for j:=1 to m do if a[n,j]>0 then write(a[n,j],' '); end. 2. Media aritmetică a elementelor aflate pe o linie s-a determinat la problema rezolvată 3. Modificările apărute sunt: - însumarea elementelor se face pentru întreaga matrice (cele

două cicluri for îmbricate) şi nu pentru o singură linie; - împărţirea se face la numărul de elemente a matricei, n*m.

program medie_aritm; var a :array[1..20,1..20] of real; n,m,i,j:integer; m_a:real; begin write('Dati nr. de linii ');readln(n); write('Dati nr. de coloane ');readln(m); writeln('Introduceti elementele '); for i:=1 to n do for j:=1 to m do begin


159

write('a(',i,',',j,')='); readln(a[i,j]); end; {Calculul mediei aritmetice} m_a:=0; for i:=1 to n do for j:=1 to m do begin m_a:=m_a+a[i,j]; end; m_a:=m_a/(m*n); writeln('Media aritmeticĂ este: ',

m_a:5:2); end. 3. Această problema se poate considera o extindere a algoritmului de căutare secvenţială, studiată la problema rezolvată 7, de la vectori.

Etape: - Se presupune la început că elementul x nu se

regăseşte în în matrice – gasit:=FALSE . - Se parcurge matricea

- dacă este îndeplinită condiţia x=a[i,j] , se afişează i şi j, linia, respectiv coloana pe care se găseşte elementul; totodată găsit ia valoarea TRUE.

- dacă elementul nu se găseşte printre elementele matricei, variabila găsit rămâne cu valoarea FALSE.

program căutare; var a:array[1..20,1..20] of integer; n,m,i,j,x:integer;

găsit:boolean; begin write('Daţi nr. de linii ');readln(n); write('Dati nr. de coloane ');readln(m); writeln('Introduceti elementele matricei'); for i:=1 to n do

for j:=1 to m do begin write('a(',i,',',j,')='); readln(a[i,j]); end; write('Dati numarul ');readln(x); {C[utarea elementului x} gasit:=FALSE; for i:=1 to n do for j:=1 to m do if x=a[i,j] then begin gasit:=TRUE; writeln('Elementul dat se află pe linia ',i,', coloana ',j); end; if gasit=FALSE then writeln('Elementul ',x,' nu se afla in matrice'); end. 4. Pentru a reţine suma elementelor de pe fiecare coloană se crează o nouă linie, cu numărul n+1. Astfel elementul a[n+1,j] va reţine suma elementelor de pe coloana j. Calculul elementului a[n+1,j] se face astfel:

- se fixează coloana j; - se iniţializează elementul a[n+1,j] cu 0; - se însumează elementele de pe coloana j,

incrementându-se indicele liniei: for i:=1 to n do

a[n+1,j]:=a[n+1,j]+a[i,j]; Matricea finală va avea n+1 linii. program suma_coloane; var a:array[1..20,1..20] of integer; n,m,i,j:integer; begin write('Dati nr. de linii ');readln(n);


160

write('Dati nr. de coloane ');readln(m); writeln('Introduceti elementele matricei'); for i:=1 to n do for j:=1 to m do begin write('a(',i,',',j,')='); readln(a[i,j]); end; for j:=1 to m do {Se fixeaza coloana j} begin a[n+1,j]:=0; {Initializarea elementului suma pentru fiecare coloana} for i:=1 to n do {Se parcurge coloana j} a[n+1,j]:=a[n+1,j]+a[i,j]; end; n:=n+1; for i:=1 to n do begin for j:=1 to m do write(a[i,j]:4); writeln; end; end. 5. Rezolvarea problemei respectă următoarele etape: - coloanele m, m-1,…,k+1, k se deplasează în această

ordine cu o poziţie spre dreapta; - inserarea vectorului in locul coloanei k; contorul i va

parcurge atât liniile matricei cât şi elementele vectorului: for i:=1 to n do

a[i,k]:=v[i]; - se incrementează numărul de coloane cu o unitate. program adaug_coloana; var a:array[1..20,1..20] of integer; v:array[1..20] of integer;

n,m,k,i,j:integer; begin write('Daţi nr. de linii ');readln(n); write('Daţi nr. de coloane ');readln(m); writeln('Introduceţi elementele matricei'); for i:=1 to n do for j:=1 to m do begin write('a(',i,',',j,')='); readln(a[i,j]); end; write('Daţi nr. coloanei ');readln(k); writeln('Introduceţi elementele vectorului'); for i:=1 to n do begin write('v(',i,')='); readln(v[i]); end; {Deplasarea coloanelor cu o poziţie spre dreapta } for j:=m downto k do {Deplasarea incepe cu ultima coloană} for i:=1 to n do a[i,j+1]:=a[i,j]; {Inserarea vectorului in locul coloanei k} for i:=1 to n do a[i,k]:=v[i]; m:=m+1; {Numărul de coloane creşte cu o unitate} writeln('Noua matrice este:'); for i:=1 to n do begin for j:=1 to m do write(a[i,j]:5); writeln; end; end. 6. Liniile matricei pot fi considerate ca vectori de dimensiune m; astfel pentru fiecare linie se poate aplica algoritmul de


161

determinare a minimului din vector – problema rezolvată 5 de la vectori.

Pentru a determina minimul pe fiecare coloană se parcurg următorii paşi: - se fixează coloana în ciclul for după j:

- se iniţializează minimul pentru fiecare coloană (min:=a[1,j]);

- se parcurge coloana cu ciclul for după i şi se testează condiţia de minim:

for i:=2 to n do if min>a[i,j] then min:=a[i,j];

- se afişează minimul pe coloana j.

program minim_coloane; type

matrice=array[1..20,1..20] of integer; var n,m,i,j,min:integer; a:matrice; begin write('n=');readln(n); write('m=');readln(m); for i:=1 to n do

for j:=1 to m do begin write('a[',i,',',j,']='); readln(a[i,j]); end;

{Determinarea minimului} for j:=1 to m do {Fixarea coloanei} begin min:=a[1,j]; {Iniţializarea minimului cu primul element al

coloanei} for i:=2 to n do {Parcurgerea coloanei} if min>a[i,j] then min:=a[i,j]; {Schimbarea valorii minimului} writeln('Minimul de pe coloana ',j,' este ',min);

end; end. 7. Programul are la bază algoritmul problemei rezolvate 2. Pentru a calcula produsul pe linii se parcurg următorii paşi: - se fixează linia în ciclul for după i:

- se iniţializează minimul pentru fiecare linie (p:=1); - se parcurge linia i cu ciclul for după j: for j:=1 to m do p:=p*a[i,j]; - se testează dacă produsul este nenul, caz în care se

afişează linia i. program produs_linie; var a:array[1..20,1..20] of integer; n,m,i,j,p:integer; begin write('Daţi nr. de linii ');readln(n); write('Daţi nr. de coloane ');readln(m); writeln('Introduceţi elementele matricei'); for i:=1 to n do for j:=1 to m do begin write('a(',i,',',j,')='); readln(a[i,j]); end; writeln('Liniile cu proprietatea cerută sunt'); for i:=1 to n do {Fixarea liniei} begin p:=1; for j:=1 to m do {Parcurgerea liniei} p:=p*a[i,j]; if p<>0 then write(i,' '); end; end.


162 write('n=');readln(n);

8. Algoritmul problemei trebuie să determine numărul de numere pare de pe fiecare linie şi determinarea maximului dintre aceste numere. Numărul de numere pare este contorizat în vectorul nr, unde nr[i] reţine numărul numerelor pare din linia i, iar variabila max, maximul din acest vector. Astfel problema se reduce la o problemă de numărare şi determinare a maximului dintr-un vector. Etape: - iniţializarea maximului cu valoarea 0; - fixarea liniei:

- se iniţializează elementul nr[i] pentru fiecare linie (nr[i]:=0);

- se parcurge linia i şi se testează condiţia de paritate - a[i,j] mod 2=0 – caz în care se incrementează elementul nr[i], corespunzător liniei i din matrice - nr[i]:=nr[i]+1;

- dacă nr[i] depăşeşte numărul maxim de numere găsit până în acest moment, se schimbă valoarea variabilei max cu elementul nr[i]:

if max<nr[i] then max:=nr[i]; Ultima instrucţiune for afişează numărul de linii cu

număr maxim de numere pare, prin compararea elementelor vectorului nr cu numărul maxim găsit (e posibil să fie mai multe astfel de numere). program nr_pare_linie; var n,m,i,j,max:integer; a:array[1..20,1..20] of integer; nr:array[1..20] of integer; begin write('n=');readln(n); write('m=');readln(m); for i:=1 to n do

for j:=1 to m do begin write('a[',i,',',j,']=');

readln(a[i,j]); end;

max:=0; for i:=1 to n do begin nr[i]:=0; for j:=1 to m do if a[i,j] mod 2=0 then nr[i]:=nr[i]+1; if max<nr[i] then max:=nr[i]; end; write('Linia (liniile) cu proprietatea cerută sunt '); for i:=1 to n do if max=nr[i] then write(i,' '); end. 9. Se preia programul de la problema anterioară; se schimbă numai condiţia de divizibilitate: elementul matricei nu trebuie să fie par - a[i,j] mod 2=0 – ci trebuie să se dividă cu 5 - a[i,j] mod 5=0. 10. Se poate adapta algoritmul de ordonare a unui vector; coloana k poate fi considerată vectorul care se ordonează. Pentru a observa diferenţa dintre matricea iniţială se va citi matricea a pe linii. După fiecare element citit pe o linie se tastează spaţiu, iar la sfârşitul liniei, tasta Enter. Pentru interschimbarea liniilor i şi i+1, se parcurg liniile şi se interschimbă elementele aflate pe aceeaşi coloană: a[i,j] şi a[i+1,j]. Program Ordonare_coloana; var n,m,i,j,k:integer; t:real; gasit:boolean; a:array[1..10,1..10] of real; begin


write('m=');readln(m); for i:=1 to n do begin write('Linia ',i,' '); {Citirea liniei i} for j:=1 to m do read(a[i,j]); end; write('Daţi numărul de ordine al coloanei:'); readln(k); {Ordonarea coloanei k} gasit:=TRUE; while gasit do {Cât timp coloana nu este ordonată} begin gasit:=FALSE; {Presupunem coloana ordonată} for i:=1 to n-1 do {Parcurgerea coloanei} begin if a[i,k]>a[i+1,k] then {Se interschimba liniile i si i+1} for j:=1 to m do {Parcurgerea liniilor i şi i+1} begin gasit:=TRUE; {Coloana nu este ordonata (elementele a[i,k] si a[i+1,k] nu respecta conditia de ordine)} t:=a[i,j]; a[i,j]:=a[i+1,j]; a[i+1,j]:=t; end ; end ; end ; for i:=1 to n do begin for j:=1 to m do write(a[i,j]:5:2); writeln; end; readln; end.

11. Se consideră matricea:

A:

⎟⎟⎟⎟⎟⎟⎟⎟⎟

⎠

⎞

⎜⎜⎜⎜⎜⎜⎜⎜⎜

⎝

⎛

−

+−

−

−

nn,n,1

ii,1ini,

1n2,2,2

n1,1,1

aa

a

aaaa

1nn,n,2

i,2i,1

n2,2,1

1n1,1,2

a...........................a..............................................................................aaa......................................................................................................a...........................a

a...........................a

Observăm relaţiile dintre indicii elementelor aflate deasupra diagonalei principale: - indicele i ia pe rând valorile 1,2,…,n-1, deci condiţia pentru i este i<=n-1 – se stabileşte un interval de valori pentru i; - valoarea indicelui j este cu o unitate mai mare decât indicele i: j>=i+1 – se stabileşte o relaţie pentru j. Pentru elementele aflate sub diagonala principală avem relaţiile: - i>=2 – elementele se află pe primele n-1 linii; - j<=i-1 – elementele se află deasupra diagonalei principale (valorile indicelui j cresc o dată cu indicele i, dar rămân cu o unitate mai mici). Pentru afişare se parcurge matricea şi se afişează: - elementul matricei, dacă indicii acestuia respectă simultan cele două condiţii; - caracterul x în caz contrar. program diagonala_principală; var a:array[1..20,1..20] of integer; n,i,j,s:integer; begin

163


164

write('Daţi dimensiunea matricei ');readln(n); for i:=1 to n do for j:=1 to n do begin write('a(',i,',',j,')='); readln(a[i,j]); end; writeln('Elementele aflate deasupra diagonalei principale'); for i:=1 to n do begin for j:=1 to n do if (i<=n-1)and (j>=i+1) then write(a[i,j]:4) else write(' ':4); writeln; end; writeln('Elementele aflate sub diagonala principală'); for i:=1 to n do begin for j:=1 to n do if (i>=2)and(j<=i-1) then write(a[i,j]:4) else write(' ':4); writeln; end; end. Pentru elementele aflate deasupra diagonalei secundare avem relaţiile: - i<=n-1 – elementele se află pe primele n-1 linii; - j< n-i+1 – elementele se află deasupra diagonalei secundare ( valorile indicelui j scad pe măsură ce creşte indicele i).

Pentru elementele aflate sub diagonala secundară avem relaţiile: - i>=2 – primele elemente se află pe linia a doua; - j<n-i-1 – elementele se găsesc sub diagonala secundarăi. program diagonala_secundara; var a:array[1..20,1..20] of integer; n,i,j:integer; begin write('Dati dimensiunea matricei ');readln(n); for i:=1 to n do for j:=1 to n do begin write('a(',i,',',j,')='); readln(a[i,j]); end; writeln('Elementele aflate deasupra diagonalei secundare'); for i:=1 to n do begin for j:=1 to n do if (i<=n-1) and (j<n-i+1) then write(a[i,j]:4) else write(' ':4); writeln; end; writeln('Elementele aflate sub diagonala secundara'); for i:=1 to n do begin for j:=1 to n do if (i>=2) and (j>n-i+1) then write(a[i,j]:4) else write(' ':4); writeln; end; end.


12. Condiţia ca un element să se găsească pe diagonala principală este: i=j – indicele de linie trebuie să fie egal cu cel de coloană. Deci elementelor a[i,j] care îndeplinesc condiţia i=j li se atribuie valoarea 1, iar în rest, 0. program matr_1_0; var a:array[1..20,1..20] of integer; n,i,j:integer; begin write('n=');readln(n); for i:=1 to n do for j:=1 to n do if i=j then a[i,j]:=1 {Elem. de pe diag. principala} else a[i,j]:=0; for i:=1 to n do begin for j:=1 to n do write(a[i,j]:5); end ; end. 13. Elementele matricei a au valorile 0 sau 1.

Pe linia i se memorează manualele primite de elevul cu numărul de ordine i. Ex. m 1 m 2 m 3 m 4

165

0 01 1 elev

1 1 0 1 3 elev0 1 1 1 2 elev

1

În acest caz elevul al 2-lea a primit primele 3 manuale, fapt indicat de elementele cu valoarea 1 de pe linia a 2-a. Numărul de manuale luate de elevul i se calculează în noua coloană, m+1, a matricei astfel: - se fixează linia prin ciclul for după i;

- se parcurge linia i şi se adună, pe rând, elementele a[i,j] ale acestei linii la elementul a[i,m+1], care reprezintă numărul de manuale primite de elevul i;

Numărul de elevi care au primit un manual j se calculează pe linia n+1:

- se fixează coloana j; - se adună elementele de pe coloana j la elementul a[n+1,j],

care reprezintă numărul de elevi care au primit manualul j.

Numărul total de manuale primite se calculează în elementul a[n+1,m+1], care însumează elementele de pe toate coloanele matricei. program manuale; type matrice=array[1..30,1..20] of integer; var n,m,i,j,maxg:integer; a:matrice; begin write('n=');readln(n); write('m=');readln(m); for i:=1 to n do for j:=1 to m do begin write('a[',i,',',j,']='); readln(a[i,j]); end; {Numarul de manuale luate de elevi} for i:=1 to n do begin a[i,m+1]:=0; for j:=1 to m do a[i,m+1]:=a[i,m+1]+a[i,j]; writeln('Elevul ',i,' a luat ',a[i,m+1],' manuale'); end; a[n+1,m+1]:=0; {Numarul de manuale la o materie} for j:=1 to m do begin


a[n+1,j]:=0; for i:=1 to n do a[n+1,j]:=a[n+1,j]+a[i,j];

writeln('Pt materia ',j,' s-au dat ',a[n+1,j],' manuale'); a[n+1,m+1]:=a[n+1,m+1]+a[n+1,j]; end;

writeln('S-a dat un nr total de',a[n+1,m+1],' manuale'); end. 14. Datele de intrare se memorează într.o matrice pătratică ale cărei elemente respectă condiţiile:

a[I,j]={jsiistrazilereinttiisecerintexistanudaca,0

jstradacuteazasecerintseistradadaca,1

Matricea a este simetrică (a[I,j]=a[j,I]=evident, dacă strada I se intersectează cu I). În vectorul inters se vor memora numărul de intersecţii pentru fiecare stradă, iar variabila max va reţine numărul maxim de intersecţii. program intersectii; type matrice=array[1..40,1..40] of integer; vector=array[1..40] of integer; var n,m,i,j,max:integer; inters:vector; a:matrice; begin write('n=');readln(n); for i:=1 to n do begin a[i,i]:=0; for j:=i+1 to n do begin write('a[',i,',',j,']='); readln(a[i,j]); {Citirea unui element} a[j,i]:=a[i,j]; {Iniţializarea elementului simetric cu aceeaşi valoare}

end; end; for i:=1 to n do {Fixarea străzii I} begin inters[i]:=0; {Iniţializarea numărului de intersecţii pentru strada I} for j:=1 to n do inters[i]:=inters[i]+a[i,j]; {Contorizarea intersecţiei cu fiecare stradă j} end; {Determinarea numarului maxim de străzi} max:=0; for i:=1 to n do if max<inters[i] then max:=inters[i]; writeln('Strazile cu numar maxim de intersectii sunt: '); for i:=1 to n do if max=inters[i] then write(i,' '); end.

166

cu legere info pascal

Documents