Probleme propuse:

1.Suma.
Se considera p numere intregi.Sa se calculeze suma:
S=1+1/n1 + 1/n2 +...+1/np.
Daca exista i apartine {1,2,...,p}astfel incat n =0,termenul corespunzator nu se
calculeaza.Totodata sa se numere valorile egale cu 0 printre numerele date.
Algoritm:
citeste p
pentru i=0,p executa:
citeste n[i]
sfarsit pentru
zerouri 0 {numarul zerourilor}
s0 {initializam suma cu 1,conform expresiei date}
pentru i=0,p executa:
citeste n[i]
daca n[i]<> 0 atunci
s  s+1/n[i]
altfel
zerouri  zerouri+1
sfarsit daca
sfarsit pentru
scrie s,zerouri
sfarsit algoritm.

2.Perechi.
Se considera n numere intregi.Sa se afiseze numerele de ordine ale perechilor
de elemente formate din doua numere intrgi egale.
Algoritm:
citeste n {dimensiunea sirului}
pentru i=1,n executa:
citeste x[i]
sfarsit pentru
pentru i=1,n-1 executa: {echivalent cu pentru i=2,n executa: }
daca x[i]=x[i+1] atunci {daca x[i-1]=x[i] atunci...}
scrie i,’ ’‚i+1
sfarsit daca
sfarsit pentru
sfarsit algoritm

3.Raport
Se considera n numere intregi.Sa se determine raportul dintre numarul
numerelor pare si numarul numerelor impare date.
Algoritm :
citeste n
pentru i=1,n executa:
sfarsit pentru
nrpare 0
nrimpare0
pentru i=1,n executa:
daca a[i] este impar atunci
nrimpare  nrimpare+1
altfel
nrpare  nrpare+1
sfarsit daca
sfarsit pentru
daca nrimpare>0 atunci
scrie nrpare/nrimpare
altfel
scrie ’Nu exista numere impare! ’
sfarsit daca
sfarsit algoritm

4.Temperaturi
Pe durata lunii iunie s-a masurat temperatura apei Marii Negre si valorile s-au
scris intr-un fisier.Stabiliti daca apa marii s-a incalzit incontinuu sau nu.
Algoritm :
pentru i=1,30 executa:
citeste t[i]
sfarsit pentru
i 1
{cat timp in a i-a zi temperatura este mai mica sau egala cu cea din a i+1-a zi}
cat timp (i<30) si (t[i]<=t[i+1]) executa :
i  i+1 {trecem la urmatoarea zi}
sfarsit cat timp
{daca valoarea lui i a atins valoarea 30,inseamna ca pana acum toate}
{perechile succesive de temperaturi au respectat temperatura}
daca i=30 atunci
scrie ’Da’
altfel
scrie ’Nu’
sfarsit daca
sfarsit algoritm
5.Intrebarea sefului
Recent s-a realizat recensamantul populatiei din Romania.Un anganjat curios a
creat un fisier in care a pastrat doar anul nasterii persoanelor care locuiesc in
comuna sa natala.Seful lui,observand ca pierde timpul cu lucruri neimportante,il
acuza ca fisierul respectiv nu este bun la nimic si pentru a fi convingator il
intreaba daca poate sa spuna cate persoane nascute anterior anului 1989 traiesc
in comuna lui?
Scrieti un program sficient care raspunde la intrebarea sefului si in plus,creeaza
un fisier nou in care se vor afla anii de nastere mai mici decat 1989.
Algoritm :
citeste n {numarul locuitorilor din comuna}
pentru i=1,n executa:
citeste an[i] {anii de nastere}
sfarsit pentru
nr  0 {deocamdata nu am gasit nici un an mai mic decat 1989}
pentru i=1,n executa:
daca an[i]<1989 atunci
nr nr+1 {creste numarul anilor mai mici decat 1989}
an[nr] an[i] {peste elementul an[nr] se copiaza valoarea
an[i]}
sfarsit daca
sfarsit pentru
daca nr=0 atunci scrie ’Nu’
altfel scrie nr {numarul locuitorilor nascuti anterior lui 1989}
pentru i=1,nr executa:
scrie an[i] {anii de nastere}
sfarsit pentru
sfarsit algoritm

6.Diriginta
La sfarsitul anului,diriginta clasei trebuie sa completeze un formular in care este
intrebata cati elevi din clasa au media finala intre 9 si 10 inclusiv,cati au media
intre 8 si 9 inclusiv etc.Dar cum nu ii place sa lucreze cu statisticile,va roaga sa
scrieti un program care ii va lista datele necesare.In plus,ea va solicita ca lista sa
contina si mediile din fiecare categorie.
Algoritm:
citeste n {numarul elevilor din clasa}
pentru i=1,n executa:
citeste m[i] {mediile}
sfarsit pentru
primul  1 {primul indice al sirului curent}
ultim  n {ultimul indice al sirului curent}
pentru limita:=9,5 executa: {medii posibile}
 p  primul {variabila auxiliara,retine primul indice al sirului curent}
aux  m[primul] {prima medie o punem deoparte}
cat timp primul<ultim executa:
{cautam primul element avand proprietatea de la dreapta spre stanga}
cat timp (primul<ultim) si nu (m[ultim]>limita) executa:
ultim  ultim-1
{m[ultim] are proprietatea ceruta,il scriem peste m[primul]}
sfarsit cat timp
daca primul<ultim atunci
m[primul]  m[ultim]
primul  primul+1
{cautam primul element care nu are proprietatea de la stanga la dreapta}
cat timp (primul<ultim) si (m[primul]>limita) executa:
primul  primul+1
sfarsit cat timp
{m[primul]nu are prorpietatea ceruta,il scriem pestem[ultim]}
daca primul<n atunci
m[ultim]  m[primul]
ultim  ultim-1 {avansam de la sfarsit spre inceput}
sfarsit daca
sfarsit daca
sfarsit cat timp
m[primul]  aux {elementul pus in aux se pune pe locul „liber”}
{daca elementul care a fost in aux are proprietatea ceruta }
{face parte din subsirul curent}
daca m[primul]>limita atunci
{indicele ultimului element care face parte din subsirul curent}
buc  primul
altfel
{m[primul] face parte din subsirul care se va partitiona in continuare}
buc  primul-1
sfarsit daca
scrie buc-p+1 {numarul elementelor din subsirul curent}
pentru j=p,buc executa:
scrie m[j]
primul buc+1 {indicele de inceput al subsirului care se va partitiona}
ultim  n {refacem variabila ultim pentru o noua prelucrare}
sfarsit cat timp
sfarsit algoritm

7.Generare sir
Se considera urmatorul sir,construit astfel incat fiecare element algoritm lui,cu
exceptia primului,se obtine din cel precedent: 1,11,21,1211,111221,...Regula de
generare a termenilor este urmatoarea:
-se numara de la stanga la dreapta cate cifre exista in termenul precedent;
-in termenul nou se trece,pentru fiecare cifra,numarul de aparitii a cifrei si cifra.
Sa se determine al n-lea element din sir.
Algoritm:
vechi[1]1 {primul termen se initializeaza si devine imediat”vechi”}
kvechi1 {lungimea sirului este acum 1}
k1 {contor pentru termenii sirului}
cat timp k<n executa:
{algoritmul se termina,cand am determinat algoritm n-lea termen }
knou0 {deocamdata nu avem nici o cifra in noul termen}
i1
cat timp i<=kvechi executa: {vom parcurge cifrele vechiului termen}
cont1 {in cont se numara toate elementele egale cu vechi[i]}
cat timp (i<kvechi) si (vechi[i]=vechi[i+1]) executa:
contcont+1
ii+1
sfarsit cat timp
knouknou+1 {sirul va avea cu un termen mai mult}
nou[knou]cont {se trece in sirul nou numarul cifrelor curente}
knouknou+1 {mai avem nevoie de o pozitie}
nou[knou]vechi[i] {pentru cifra curenta}
ii+1 {trecem la urmatoarea cifra din termenul vechi}
sfarsit cat timp
vechinou
kvechiknou
kk+1
sfarsit cat timp
pentru i=1,knou executa:
scrie nou[i]
sfarsit pentru
sfarsit algoritm

8.Suprapunere
Se considera un tablou unidimensional A care contine n numere naturale si un
alt tablou B(avand elemente egale cu 1) de lungime k,unde k<=n.Prin
suprapunerea tabloului B peste tabloul A elementele acoperite din A isi
micsoreaza valoarea cu o unitate.Sa se stabileasca daca este posibil ca prin
aplicari succesive ale tabloului B peste tabloul A sa se obtina in A valori egale
cu 0.
Algoritm:
 citirea datelor
i1
p0
pozitivadevarat {initial toate numerele din A sunt nenegative}
{cat timp numerele din A sunt nenegative si B”incape”inA}

cat timp pozitiv si (i<=n-k+1)executa:

{daca elementul curent este diferit de 0,vom realiza o suprapunere}
daca a[i]<>0 atunci
j1
pp+1 {vom avea un element nou in rez}
cat timp pozitiv si (j<=k) executa:
{scadem 1 din k elemente din A,incepand cu a[i]}
a[i+j-1]a[i+j-1]-1
{verificam daca noile elemente din A sunt nenegative}
daca a[i+j-1]<0 atunci
pozitivfals
jj+1
sfarsit cat timp
daca poziti atunci
rez[p]i {retinem pozitia de suprapunere}
sfarsit daca
sfarsit daca
daca a[i]=0 atunci {daca elementul curent are valoarea 0 avansam}
ii+1
sfarsit daca {altfel ,incercam o noua suprapunere incepand cu pozitia i}
sfarsit cat timp
daca pozitiv atunci {daca prin suprapunere nu am obtinut numar negativ}
in
{verificam elementele de la sfarsitul sirului A,pentru a vedea daca nu sunt
nule}
cat timp(a[i]=0) si (i>=1) executa:
ii-1
sfarsit cat timp
{daca toate elementele din A au valoarea0,avem rezultat}
daca i=0 atunci okadevarat
altfel okfals
sfarsit daca
daca pozitiv si ok atunci
pentru i=1,p executa:
scrie rez[i]
sfarsit pentru
altfel
 scrie ’Imposibil’
sfarsit daca
sfarsit algoritm

9.Cifre comune
Sa se afiseze cifrele comune a doua numere naturale date.
Subalgoritm Creare_multime(numar,M): {subprogram procedura}
pentru cifra=0,p executa: {deocamdata multimea M este vida}
M[cifra]fals
sfarsit pentru
cat timp numar<>0 executa:
cifrarest[numar/10]
M[cifra]adevarat {cifra cifra exista in numar}
Numar[numar/10]
sfarsit cat timp
sfarsit subalgoritm

Subalgoritm intersectie(A,B,inters): {subprogram tip procedura}

pentru cifra=0,9 executa: {deocamdata intersectia este vida}
inters[cifra]fals
sfarsit pentru
pentru cifra=0,9 executa:
daca A[cifra] si B[cifra] atunci {daca cifra se afla si in A si in B}
inters[cifra]adevarat
sfarsit daca
sfarsit pentru
sfarsit sub algoritm

Subalgoritm Afisare (inters): {subprogram de tip procedura}

existafals
pentru cifra=0,9 executa:
daca inters[cifra] atunci
scrie cifra
existaadevarat {am gasit o cifra comuna}
sfarsit daca
daca nu exista atunci
scrie ’Nu exista cifre comune.’
sfarsit daca
sfarsit subalgoritm

10.Prime si „inversele” lor prime

Sa se genereze toate perechile de numere prime formate din trei cifre care au
proprietatea de a fi,unul inversul celuilalt.Aici prin „invers”intelegem numarul
format din cifrele numarului dat,in ordine inversa.
Algoritm Prime:
pentru numar=101,997 executa:
daca Prim (numar) si Prim(invers(numar)) atunci
scrie numar,invers
sfarsit daca
sfarsit pentru
sfarsit algoritm

Algoritm Prime_si_inversate_prime_2:
pentru a=1,9 executa: {prima cifra din nr nu poate fi 0}
pentru b=0 la 9 executa:
{ultima cifra trebuie sa fie cel putin egala cu prima cifra}
numara*100+b*10+c
inversc*100+b*10+a
daca Prim (numar) si Prim(invers) atunci
scrie numar,invers
sfarsit daca
sfarsit daca
sfarsit pentru
sfarsit pentru
sfarsit pentru
sfarsit algoritm

11.Eliminare de numere patrate perfecte si prietene

Se considera un sir de numere naturale.Sa se elimine din acest sir toate numerele
perfecte,precum si perechile de numere prietene aflate pe pozitii consecutive.
Subalgoritm Elimin(a,n,pozitie): {subprogram tip procedura}
pentru i=pozitie ,n-1 executa: {se deplaseaza elementele tabloului}
a[i]a[i+1] {cu o pozitie la stanga,incepand cu pozitie+1}
sfarsit pentru
nn-1 {nr de elemente scade}
sfarsit algoritm

Subalgoritm Suma _divizori(numar): {subprogram tip functie}

S1 {in aceasta suma se adauga si 1 }
pentru d=2,[numar/2] executa:
daca reset [numar/d]=0 atunci
ss+d
sfarsit daca
 sfarsit pentru
Suma _divizorid
sfarsit subalgoritm

Subalgoritm Perfect(numar): {subprogram tip functie}

daca Suma_divizori(numar)=numar atunci
Perfectadevarat
altfel
Perfectfals
sfarsit daca
sfarsit subalgoritm

Subalgoritm Prietene(numar1,numar2): {subprogram tip functie}

daca (Suma_divizori(numar1)=numar2) si
(Suma_divizori(numar2)=numar1) atunci
Prieteneadevarat
altfel Prietenefals
sfarsit daca
sfarsit subalgoritm

12.Generarea cuvantului de lungime maxima

Sa se determine cuvantul de lungime maxima care poate fi construit din literele
unui text, astfel incat caracterele cuvantului sa fie in ordine alfabetica si sa fie
culese din text exact in ordinea in care se afla in cuvant(nu neaparat pe pozitii
succesive).
Subalgoritm Caut(n,textul):
L[n]1 {cel mai lung cuvant care incepe cu a n-a litera are lungimea 1}
urm[n]0 {dupa ultima litera nu urmeaza alt caracter}
pentru i=n-1,1 executa:
max  0
indice o
pentru j=i+1,n executa:
{incercam sa punem litera textul[i] in fata lui textul[j]}
daca (textul[i]<>’ ’) si (textul[j]<>’ ’) si (textul[i]<textul[j]) atunci
daca L[i]>max atunci {dintre literele in fata carora se poate}
{pune a i-a litera, o alegem pe cea cu care incepe cel mai lung cuvant}
maxL[j]
indice j
sfarsit daca
sfarsit daca
sfarsit pentru
 daca textul[i]<>’ ’ atunci
{cel mai lung cuvant care incepe cu a i-a litera este egala cu lungimea celui mai
lung cuvant in fata caruia punem a i-a litera(max)+1}
L[i] max+1
altfel
L[i] 0 {daca am avut caracter spatiu}
sfarsit daca
urm[i]indice {in indice am tinut minte in fata carei litere o punem}
sfarsit pentru
Maxim {cautam lungimea maxima din L}
Scrie
sfarsit subalgoritm

Subalgoritm Scrie:
scrie textul[indice] {afisam litera cu care incepe cel mai lung cuvant}
i urm[indice] {indicele literei urmatoare}
cat timp i>0 executa: {cat timp exista urmator}
scrie textul[i]
i urm[i] {indicele literei care urmeaza dupa cea afisata}
sfarsit cat timp
sfarsit subalgoritm

13.Conversie din baza 10 in alta baza

Sa se converteasca numarul natural n,din baza 10 intr-o alta baza de numeratie
mai mica decat 37.Cifrele noului numar se vor pastra intr-o stiva.
Subalgoritm Conversie(nr,b,rez):
Rez’ ’
repeta
cat [nr/b] {calculam catul si restul impartirii la baza}
r  rest[nr/b] {din r construim cifra corespunzatoare in baza b}
daca r in {0,1,...9} atunci
c chr(ord(’0’)+r)
altfel
cchr(ord(’A’)+r-10)
sfarsit daca
nrcat {schimbam valoarea lui nr pentru pasul urmator}
rezc+rez {adaugam cifra la rezultat(o alipim)}
pana cand nr=0
sfarsit subalgoritm

14.Tija cu bile
Pe o tija verticala sudata la baza sunt dispuse n bile perforate in centru si
numerotate cu numere intregi oarecare.Se doreste eliminarea bilei etichetate cu
numarul x,folosindu-se de o alta tija verticala pe care pot fi mutate temporar
bile.Scrieti un program care citeste numerele asociate celor n bile,depune bilele
pe tija,apoi,folosind tija de manevra,elimina bila avand eticheta numarul x.

Subalgoritm CreareStiva(tija1,vf1): {DimStiva=100}

Vf1 0 {initializare stiva 1}
{citirea numerelor si crearea stivei corespunzatoare tijei 1}
scrie ’Se introduc pe tija: ’
dim0 {variabila auxiliara}
cat timp fisierul nu este gol si (dim<DimStiva) executa:
citeste nr
dim dim+1
scrie nr
AdaugareInStiva(tija1,vf1,nr)
sfarsit cat timp
daca fisierul nu este gol atunci {nu am putut citi intregul fisier de intrare}
scrie ’Stiva este plina!’
Oprire fortata algoritm
sfarsit daca
sfarsit subalgoritm

Subalgorim CautaBila(tija1,vf1,tija2,vf2,x):
vf2 0 {initializare stiva 2}
scrie ’Se extrag:’ {extragerea de pe tija 1 a bilelor pana la intalnirea
bilei avand ca eticheta numarul cautat}
cat timp (vf1>0) si (tija1[vf1]<>x) executa:
ExtragereDinStiva(tija1,vf1,nr)
scrie nr
AdaugareInStiva(tija2,vf2,nr)
sfarsit cat timp
daca tija[vf1]=x atunci {am ajuns la bila cautata care se elimina}
ExtragereDinStiva(tija1,vf1,nr)
altfel
scrie ’Nu exista bila cu eticheta’,x
sfarsit daca
sfarsit subalgoritm

Subalgoritm Muta(tija1,vf1,tija2,vf2,x):
{bilele de tija 2 sunt puse la loc pe tija 1}
cat timp vf2>0 executa:
ExtragereDinStiva(tija 2,vf2,nr)
 AdaugareInStiva(tija1,vf1,nr)
sfarsit cat timp
sfarsit subalgoritm

Subalgoritm Afisare(tija1,vf1):
Scrie ’Au ramas pe tija: ’
vf2 0
cat timp vf1>0 executa:
ExtragereDinStiva(tija1,vf1,nr)
scrie nr {scrierea in fisier a bilelor ramase}
AdaugareInStiva(tija2,vf2,nr)
sfarsit cat timp
sfarsit subalgoritm

15.Tija cu bile colorate

Pe o tija verticala se gasesc amestecate m bile colorate,avand n culori posibile.
Sa se separe aceste bile,punandu-le pe n tije colorate,fiecare bila de pe o anumita
tija avand culoarea tijei.Bilele sunt numerotate de la 1 la m,iar culorile sunt
codificate cu numere de la 1 la n.

Subalgoritm Creare(st,varf): {se creeaza stiva initiala cu toate bilele}

varf0
citeste m,n {numarul bilelor si culorilor}
pentru i=1,m executa:
citeste culoare {culoarea bilei}
AdaugareInStiva(st,varf,culoare)
sfarsit pentru
sfarsit subalgoritm

Subalgoritm Distribuie(st,varf,stive,varfuri):
pentru i=1,n executa: {initializarea celor n stive}
varfuri[i]0
sfarsit pentru
{luam bilele de pe tija initiala si le distribuim pe stive conform culorilor}
nr_bilam
cat timp varf>0 executa:
ExtragereDinStiva(st,varf,culoare)
AdaugareInStiva(stive[culoare],varfuri[culoare],nr_bila)
nr_bilanr_bila-1
sfarsit cat timp
sfarsit subalgoritm
 Subalgoritm AfisareStiva(st,varf):
cat timp varf>0 executa:
ExtragereDinStiva(st,varf,nr_bila);
scrie nr_bila
sfarsit cat timp
sfarsit subalgoritm

16.Valoarea unei expresii aritmetice

Se citeste o expresie aritmetica in care se folosesc operatorii binari:+,-,*,/,%,
unde prin operatorul „/” vom intelege catul impartirii intregi al primului
operand la al doilea,iar prin operatorul „%”,restul impartirii intregi.Variabilele
acestei expresii au identificatori formati dintr-o singura litera.Nu se folosesc
constante.
Sa se verifice daca expresia este corect scrisa,iar in caz afirmativ,sa se
determine forma poloneza postfixata a acesteia si sa se calculeze valoarea
expresiei pentru valori ale variabilelor citite ca date de intrare.

a)Subalgoritm Corecta(s):
nlungimea sirulu de caractere s
p_deschise0
{variabila auxiliara,la sfarsit valoarea ei se atribuie identificatorului de
functie}
coradevarat
daca s[1]=’ ( ’ atunci {primul caracter il tratam separat}
p_deschisep_deschise+1
sfarsit daca
daca s[1]=’ )’ atunci
corfals
sfarsit daca
{sa nu inceapa sau sa se termine cu operator}
daca (s[1] este operator) sau (s[n] este operator) atunci
corfals
sfarsit daca
i2
cat timp (i<=n) si cor executa:
daca s[i] nu este litera si nu este operator si nu este paranteza atunci
corfals
sfarsit daca
{daca numele unei variabile este format din mai multe litere}
daca (s[i] este litera) si (s[i-1] este litera) atunci
corfals
sfarsit daca
 {sau daca exista 2 operatori ce se succed,expresia nu este corecta}
daca (s[i] este operator) si (s[i-1] este operator) atunci
corfals
sfarsit daca
daca s[i]=’ ( ' atunci {se numara parantezele cand se deschid}
p_deschisep_deschise+1
{daca inaintea unei ' ( ’ avem o variabila sau ’ ) ’ ,expresia nu e corecta}
daca (s[i-1] este litera) sau (s[i-1]=’ ) ’) atunci
corfals
sfarsit daca
sfarsit daca
daca s[i]=’ ) ’ atunci {se inchide o paranteza deschisa}
daca p_deschise<=0 atunci {daca se inchide una nedeschisa}
corfals
altfel
p_deschisep_deschise-1
sfarsit daca
{daca in fata unei paranteze inchise este un operator}
daca s[i-1] este operator atunci
corfals
sfarsit daca
sfarsit daca
ii+1
sfarsit cat timp
corectacor
sfarsit subalgoritm

b)Subalgoritm Forma_postfixata(s,rezultat):
vfoper0
vfpolon0
multime{} {formam multimea de variabile din expresie}
pentru i=1,lungimea lui s executa: {prelucram fiecare caracter al expresiei}
{caracterul litera sau paranteza deschisa se introduce in polon si se adauga
la multimea de litere de care vom avea nevoie pentru a citi valorile
variabilelor}
daca s[i] este litera atunci
adaug(polon,vfpolon,s[i]) {se aduga in polon}
multime  multime +s[i]
sfarsit daca
daca s[i]=’ ( ’ atunci
adaug(oper,vfoper,s[i]) {se adauga in oper}
sfarsit daca
{caracterul operator se introduce in oper}
 {doi operatori consecutivi de aceeiasi prioritate se inverseaza }
daca (s[i]=’ * ’) sau (s[i]=’ / ’) sau (s[i]=’ % ’) atunci
daca (vfoper<>0) si (prioritate(oper[vfoper])=prioritate(s[i]) atunci
Extrag(oper,vfoper,ce)
Adaug(polon,vfpolon,ce)
sfarsit daca
Adaug(oper,vfoper,s[i])
sfarsit daca
{operatorii cu prioritate mica se muta din oper in polon pana cand in varful
stivei oper nu se va mai afla un operator ’ * ’,’/’ sau ’%’ }
daca (s[i]=’+’) sau (s[i]=’-’)atunci
{operatorii cu prioritate mai mare se scot din oper si se introduc in polon}
cat timp (vfoper<>0) si
(Prioritate (oper[vfoper])<prioritate(s[i])) executa:
Extrag(oper,vfoper,ce)
Adaug(polon,vfpolon,ce)
sfarsit cat timp
Adaug(oper,vfoper,s[i]) {se adauga operatorul + sau -}
sfarsit daca
{caracterul curent este paranteza inchisa:se muta toti operatoriidin oper in
polon pana la intalnirea parantezei deschise corespunzatoare}
{paranteza deschisa se elimina din oper}
daca s[i]= ’ ) ’ atunci {expresia dintre doua paranteze deschise}
{se muta in polon si se elimina din oper paranteza deschisa}
cat timp oper[vfoper]<>’ ( ’ executa:
Extrag(oper,vfoper,ce)
Adaug(polon,vfpolon,ce)
sfarsit cat timp
Extrag(oper,vfoper,ce) {eliminam ’ ( ’}
sfarsit daca
sfarsit pentru
{tot ceea ce a ramasain oper se muta in polon}
cat timp vfoper<>0 executa:
Extrag(oper,vfoper,ce)
Adaug(polon,vfpolon,ce)
sfarsit cat timp
sfarsit subalgoritm

c)Subalgoritm valoare_expresie(s): {returneaza un intreg}

pentru i=1,n executa:
daca s[i] este litera atunci
v[i] valoarea numerica a variabilei avand identificatorul in s[i]
altfel
 v[i]0
sfarsit daca
sfarsit pentru
repeta {cautam primul operator pentru a efectua intai acea operatie}
i1
cat timp (s[i]<>’+’) si (s[i]<>’ *’) si (s[i]<>’-’) si (s[i]<>’%’) si (s[i]<>’/’) si
(i<n) executa:
ii+1
sfarsit cat timp
{efectuam operatia}
daca s[i]=’+’ atunci rezv[i-2] + v[i-1]
altfel
daca s[i]=’-’ atunci rez v[i-2] – v[i-1]
altfel
daca s[i]=’*’ atunci rezv[i-2]*v[i-1]
altfel
daca s[i]=’/’ atunci rez  [v[i-2]/v[i-1]]
altfel
daca s[i]=’%’ atunci rez rest[v[i-2]/v[i-1]]
sfarsit daca
sfarsit daca
sfarsit daca
sfarsit daca
sfarsit daca
daca (i=n) si (s[i] este litera) atunci gataadevarat
altfel gatafals
daca nu gata atunci
{stergem unul din operanzi si operatorul efectuat din expresie si din sirul v se
sterg din s doua caractere incepand cu pozitia i-1 }
{valoarea calculata devine in sirul v valoarea variabilei pastrate}
v[i-2]rez
{stergem din v 2 elemente incepand cu pozitia i-1}
pentru k=i-1,n executa:
v[k]v[k+2]
nn-2
sfarsit pentru
sfarsit daca
pana cand gata
{am ramas cu o singura variabila care contine valoarea expresiei}
valoarea_expresiev[1]
sfarsit algoritm
17.Unificarea listelor
La inspectoratul scolar s-au strans n liste din scolile judetului de la examenul de
capacitate.Din pacate,unele liste sunt ordonate crescator dupa mendii,altele
descrescator.Ajutati inspectoratul scolar si scrieti un program care creeaza o
singura lista din cele n liste in care mediile sa fie ordonate descrescator.
Algoritm Liste:
citirea datelor de intrare: {n,med,cod,dim}
cat timp n<=2 executa: {pana la interclasarea ultimelor 2 siruri}
indsir1Minim(n,dim) {indicele sirului de dimensiune minima}
adimdim[indsir1] {in adim pastram dimensiunea celui mai scurt sir}
acod cod[indsir1] {in acod pastram cel mai scurt sir de coduri}
amedmed[indsir1] {in amed pastram cel mai scurt sir de medii}
Elimin(n,indsir1,dim,cod,med) {eliminam cel mai scurt sir}
indsir2  Minim(n,dim) {procedam la fel cu al doilea cel mai scurt sir}
bdim dim[indsir2]
bcodcod[indsir2]
bmedmed[indsir2]
Elimin(n,indsir2,dim,cod,med)
daca amed[1]<amed[2] atunci {verificam sensul de ordonare}
Invers(adim,acod,amed) {daca este in sens crescator, il inversam}
sfarsit daca
daca bmed[1]<bmed[2] atunci
Invers(bdim,bcod,bmed)
{interclasam acod cu bcod in ccod si amed cu bmed in cmed }
sfarsit daca
Inter(acod,bcod,ccod,amed,bmed,cmed,adim,bdim,adim+bdim)
Adaug (n,ccod,cmed,adim+bdim,cod,med,dim)
sfarsit cat timp
{rezultatul este in ultimul rezultat al interclasarii}
Afisare(ccod,cmed,adim+bdim)
sfarsit algoritm

Subalgoritm Elimin(n,ind,dim,cod,med):
{eliminam sirurile care se vor interclasa}
i1
cat timp (i<=n) si (i<>ind) executa:
i i+1
sfarsit cat timp
pentru j=i,n-1 executa: {incepand cu al i+1-lea translatam la stanga}
dim[j]dim[j+1]
cod[j]cod[j+1]
med[j]med[j+1]
sfarsit pentru
 nn-1 {sirul devine mai scurt}
sfarsit subalgoritm

Subalgoritm Adaug(n,ccod,cmed,d,cod,med,dim):
{adaugam sirul interclasat}
n  n+1 {sirul devine mai lung}
dim[n] d
cod[n] ccod
med[n] cmed
sfarsit subalgoritm

Subalgoritm Invers(d,cod,med):
{daca sirul de medii este ordonat crescator,inversam ordinea}
pentru i=1 ,[d/2] executa:
aux1 med[i]
med[i]  med[d-i+1]
med[d-i+1] aux1
aux2  cod[i]
cod[i]  cod[d-i+1]
cod[d-i+1]  aux2
sfarsit pentru
sfarsit subalgoritm

18.Alegeri prezidentiale
Se apropie alegerile si organizatorii se pregatesc cu pachete de programe cu
care sa-si usureze munca in viitorul apropiat.Se prevede ca la alegerile
prezidentiale vor fi foarte multi candidati.Scrieti un program care va stabili pe
baza voturilor daca exista sau nu un castigator la aceste alegeri.Se considera ca
pentru a castiga ,un candidat trebuie sa totalizeze un numar de voturi cel putin
cu 1 mai mult decat jumatae din numarul total de voturi.

Algoritm Alegeri_prezidentiale:
citeste nr
candidat  nr
cate  1 {in cate numaram voturi egale pe „segmente” de date}
cat timp nu urmeaza marca de sfarsit de fisier executa:
citeste nr
daca nr=candidat atunci {daca a aparut vot pentru acelasi candidat }
cate  cate+1
altfel {daca votul nu este pentru candidatul curent}
cate  cate-1 {micsoram numarul voturilor primite de candidat}
{daca prin micsorare numarul voturilor devine 0 }
 daca cate=0 atunci
candidat  nr {schimbam candidatul cu ultimul votat}
cate  1 {pentru acesta a aparut primul vot}
sfarsit daca
sfarsit daca
sfarsit cat timp
{am terminat prelucrarea fisierului;am iesit cu un candidat}
{deoarece nu este sigur ca acesta are suficiente voturi}
cate  0 {parcurgem fisierul din nou}
n0
cat timp nu urmeaza marca de sfarsit de fisier executa:
citeste nr
n  n+1 {numaram numarul voturilor}
daca nr=candidat atunci {si numarul voturilor primite de candidat}
cate  cate+1
sfarsit daca
sfarsit cat timp
daca cate >[n/2] atunci
scrie ’Da’
scrie candidat
altfel
scrie ’Nu’
sfarsit algoritm

19.Casierul unei firme trebuie sa parcurga zilnic un traseu liniar prin cele n
magazine ale sale.Magazinele sunt numerotate de la 1 la n si se parcurg zilnic in
ordinea numerelor lor de ordine,incepand cu primul magazin si terminand cu al
n-lea.(Evident casierul va trece doar o singura data prin fiecare magazin).Scopul
parcurgerii acestui traseu este efectuarea unor plati,respectiv a unor incasari.Se
stie ca exista cel putin un magazin de unde casierul va incasa bani.De asemenea
se cunosc sumele care trebuie platite,respectiv incasate.
Intr-o zi,patronul nu are bani pentru plati si cere casierului sa aleaga 2
magazine mi si mj de pe traseu,astfel incat parcurgand traseul incepand cu mi si
incheindu-l cu mj,incasarile sa reprezinte suma maxima posibila de adus inapoi
la firma.Casierul trebuie sa intre in toate magazinele aflate pe traseul ales,chiar
daca in unele trebuie sa efectueze plati.In plus,pentru a nu crea suspiciuni printre
angajatii magazinelor,patronul doreste sa fie vizitate cat mai multe magazine.
Scrieti un program care determina suma maxima posibila de incasat din
magazinele firmei.De asemenea,determinati secventa cea mai lunga de magazine
care permite obtinerea acestei sume.Daca aceeasi suma maxima se poate obtine
prin mai multe alegeri diferite,vizitand acelasi numar maxim de magazine,atunci
in fisierul de iesire se va scrie una singura,si anume cea care incepe de la
magazinul cu numarul de ordine cel mai mic.
Subalgoritm Subsecventa_1(n,T):
Max  T[1] {T este sirul dat,Max este suma maxima cautata}
pentru stanga=1,n executa: {stanga este primul indice al subsecventei}
{dreapta este ultimul indice al subsecventei}
pentru dreapta=stanga,n executa:
suma 0
pentru i=stanga,dreapta executa:
suma  suma +T[i]
sfarsit pentru
daca Max<suma atunci
Max suma
sfarsit daca
sfarsit pentru
sfarsit pentru
sfarsit subalgoritm

Subalgoritm Subsecventa_2(n,T):
Max T[1] {T este sirul dat,Max este suma maxima cautata }
pentru stanga=1,n executa: {stanga este primul indice al subsecventei}
suma 0 {incepand cu fiecare stanga nou,avem suma noua}
pentru dreapta=stanga,n executa:
suma suma +T[dreapta] {adaugam un element nou}
daca Max<suma atunci
Max<suma {actualizam Max}
sfarsit daca
sfarsit pentru
sfarsit pentru
sfarsit subalgoritm

Algoritm Subsir_de_suma_maxima_3:
citeste n
citeste T
MaxS_Caut T {initializarea sumei maxime}
MaxS_AiciMaxS_Caut {initializrea sumei curente}
poz_inc1
sfarsit 1
inceput1
pentru i=2,n executa: {continuam citirea numerelor}
citeste T
daca MaxS_Aici<0 executa: {daca MaxS_Aici este negativa}
MaxS_Aici T {aceasta se reinitializeaza cu T}
Poz_inc i {noul subsir posibil incepe cu pozitia i}
 altfel
MaxS_AiciMaxS_Aici+T {lui MaxS_Aici i se adauga T}
daca MaxS_Caut<=MaxS_Aici atunci {se actualizeaza MaxS_Caut}
daca MaxS_Caut<MaxS_Aici atunci
MaxS_CautMaxS_Aici
inceput poz_inc
sfarsit i
altfel {in caz de egalitate}
daca inceput=poz_inc atunci
sfarsit  i
sfarsit daca
sfarsit daca
sfarsit daca
sfarsit daca
sfarsit pentru
scrie MaxS_Caut
scrie inceput,’ ’,sfarsit
sfarsit algoritm