Cap · Web view2014-10-12 · ... 12. b+=c+d+a este : 20. ... Exemplu: pentru n=7 şi vectorul 2,...

Caiet de laborator pentru clasa a IX-a

CUPRINS

CAP.1 FUNCŢII DE CITIRE/SCRIERE.........................................................................2

1.1 Funcţii de citire/scriere pentru caractere şi şiruri de caractere.......................................2A. Probleme rezolvate...............................................................................................................2B. Probleme propuse.................................................................................................................4

1.2 Funcţiile de citire/scriere cu format....................................................................................5A. Probleme rezolvate...............................................................................................................5B. Probleme propuse.................................................................................................................9

CAP.2 OPERATORII LIMBAJULUI C.......................................................................11A. Probleme rezolvate.............................................................................................................11B. Probleme propuse...............................................................................................................22

CAP.3 STRUCTURI DE CONTROL..........................................................................26

3.1 Structura secvenţială şi alternativă...................................................................................26A. Probleme rezolvate.............................................................................................................26B. Probleme propuse...............................................................................................................29

3.2 Structura repetitivă (iterativă)..........................................................................................31A. Probleme rezolvate.............................................................................................................31B. Probleme propuse...............................................................................................................69

CAP.4 TABLOURI....................................................................................................74

4.1 Tablouri unidimensionale (vectori)...................................................................................74A. Probleme rezolvate.............................................................................................................74B. Probleme propuse.............................................................................................................106

1

Caiet de laborator pentru clasa a IX-a

Cap.1 Funcţii de citire/scriere

1.1 Funcţii de citire/scriere pentru caractere şi şiruri de caractere

A. Probleme rezolvate

2

Caiet de laborator clasa a IX-a

1. Citiţi fără ecou un caracter imprimabil sau alb, tastat la terminalul standard şi apoi afişaţi-l pe ecranul acestuia.#include<conio.h>void main(){ int c;

clrscr();//caracterul citit fără ecou se memorează în cc=getch();

//se afişează caracterul; pe ecran apare o singură //dată putch(c);

getch();}

2. Citiţi cu ecou un caracter imprimabil sau alb şi afişaţi-l pe ecran precedat de un spaţiu.#include<conio.h>void main(){ int c;

clrscr();c=getche(); //citirea caracterului cu ecouputch(‘ ‘); //afişarea spaţiului care îl precedeputch(c); //afişarea caracteruluigetch();

}

3. Citiţi un caracter alb sau imprimabil folosind macrourile getchar şi putchar .#include<stdio.h>#include<conio.h>void main(){ int c;

clrscr();c=getchar(); //citirea bufferată a caracteruluiputchar(c); //afişarea caracteruluigetch();

}

4. Citiţi cu ecou o litera mică şi afişaţi-o ca literă mare .#include<conio.h>void main(){ int lit;

clrscr();lit=getche(); //citirea literei cu ecou

//transformarea în literă mare şi afişareaputch(lit-‘a’+’A’); getch();

} Observaţie: Dacă caracterului citit nu este o literă mică, programul anterior nu poate afişa o literă mare ci un caracter ASCII care are codul obţinut după calculul anterior.

5. Rezolvaţi problema anterioară folosind macrourile getchar şi putchar .#include<stdio.h>#include<conio.h>void main(){ clrscr();

putchar(getchar()-‘a’+’A’);getch();

}

6. Citiţi de la terminalul standard o succesiune de caractere imprimabile şi reafişaţi-o pe ecran, după ce l-aţi şters .#include<stdio.h>#include<conio.h>

3


void main(){ char tab[255];

clrscr();gets(tab); //citeşte şirul de caractereclrscr(); //curăţă ecranulputs(tab); //reafişează şirul de caracteregetch();

}Observaţie: Rulaţi acest program pentru şiruri care conţin caractere albe (blancuri şi tab-uri) şi studiaţi comportamentul funcţiei gets() pentru astfel de şiruri. 7. Să se afişeze pe câte un rând fiecare cuvânt al textului : INVAT LIMBAJUL C.

#include<stdio.h>#include<coio.h>void main(){ clrscr();

puts(“INVAT”);puts(“LIMBAJUL”);puts(“C”);getch();

}Observaţie: Reamintim că funcţia puts() scrie un caracter newline după şirul pe care îl are drept argument, mutând cursorul la începutul liniei următoare.

B. Probleme propuse

1. Citiţi cu ecou un caracter imprimabil sau alb, tastat la terminalul standard şi apoi afişaţi-l pe ecran.

2. Citiţi cu ecou o literă mare şi apoi afişaţi-o ca literă mică.3. Rezolvaţi problema anterioară folosind macrourile getchar() şi putchar().4. Rezolvaţi problemele A.3 şi A.4 fără a folosi o variabilă intermediară în care să memoraţi

caracterul citit.5. Scrieţi un program care să citescă un caracter de control(ex.F1,F2) şi afişaţi “imaginea”

acestuia. Studiaţi modul în care trebuie utilizată funcţia getch() pentru aceste caractere. 6. Scrieţi un program care să se afişeze antetul de mai jos :

linia 1 Notele la disciplinalinia 4 LIMBAJUL Clinia 6 8 Noiembrie 2000linia 10 Nr.crt. Nume Prenume Notaunde :

- cuvântul "Notele" se afişează începând cu coloana 15 din linia 1- cuvântul "LIMBAJUL" se afişează începând cu coloana 30 din linia 4- data calendaristică se afişează începând tot cu coloana 30 din linia 6- in linia 10 , cuvintele încep după cum urmează :

Nr.crt. începe în coloana 2 Nume începe în coloana 18 Prenume începe în coloana 37 Nota începe în coloana 50

1.2 Funcţiile de citire/scriere cu format


1. Citiţi un caracter şi afişaţi-l pe ecran precedat de un spaţiu .#include<stdio.h>#include<conio.h>void main(){ char c; clrscr();

scanf("%c",&c); //citirea caracterului

4


printf("%2c",c); //afişarea pe un câmp de lungime 2getch();

}

2. Citiţi un caracter şi afişaţi-l pe ecran precedat şi urmat de câte un asterisc.#include<stdio.h>#include<conio.h>void main(){ char c;

clrscr();scanf("%c",&c); //citirea caracteruluiprintf("*%c*",c); //afişarea in formatul cerutgetch();

}

3. Citiţi un caracter şi afişaţi-l într-un câmp de 3 caractere, aliniat la dreapta, câmpul fiind precedat şi urmat de câte un asterisc.#include<stdio.h>#include<conio.h>void main(){ char c;

clrscr();scanf("%c",&c); //citirea caracterului

//afişarea pe un câmp de lungime 3 şi //încadrat de asteriscprintf("*%3c*",c); getch();

}

4. Citiţi o cifră zecimală ca şi caracter şi afişaţi-o precedată de 3 zerouri nesemnificative . #include<stdio.h>#include<conio.h>void main(){ char c;

clrscr();scanf("%c",&c); //citirea unui caracter

//afişarea caracterului precedat de 3 zerouriprintf("000%c",c); getch();

}

5. Citiţi un şir de maxim 50 de caractere şi afişaţi-l pe ecran pe o linie nouă.#include<stdio.h>#include<conio.h>void main(){ char t[51];

clrscr();scanf("%s",t); //citirea şiruluiprintf("\n%s",t); //afişarea pe o linie nouăgetch();

}

6. Citiţi un număr întreg de 4 cifre şi afişaţi-l pe ecran folosind următorii specificatori de format : %d, %o, %x, %X, %7d, %-7d, %07d. Câmpul va fi precedat şi urmat de un asterisc. Analizaţi valoarea afişată pentru fiecare specificator în parte şi justificaţi-o teoretic.#include<stdio.h>#include<conio.h>void main(){ int i;

clrscr();scanf("%4d",&i); //citirea unui întreg de 4 cifre

5


printf("*%d*\n",i);printf("*%o*\n",i);printf("*%x*\n",i);printf("*%X*\n",i);printf("*%7d*\n",i);printf("*%-7d*\n",i);printf("*%07d*\n",i);getch();

}7. Citiţi un caracter şi scrieţi-l pe o linie nouă urmat de codul său ASCII .

#include<stdio.h>#include<conio.h>void main(){ char car;

clrscr();scanf("%d",&car); //citirea caracteruluiprintf("caracterul: %c are codul ASCII:

%d\n",car,car);getch();

}Observaţie: Reamintim că în limbajul C tipul char este tratat ca un întreg scurt. Specificatorul %c va trata valoarea ca pe un caracter, în timp ce specificatorul %d ca pe un întreg, adică va afişa codul său ASCII.

8. Citiţi o literă mare şi afişaţi-o ca literă mică .#include<stdio.h>#include<conio.h>void main(){ char c;

clrscr();scanf("%c",&c); //citirea caracterului//afişarea ca literă micăprintf("%c\n",c-'A'+'a'); getch();

}

9. Citiţi numele şi prenumele unei persoane de la tastatură şi apoi afişaţi datele respective pe o linie nouă separate printr-un tabulator. Se presupune că atât numele cât şi prenumele nu depăşesc fiecare 50 de caractere şi se separă prin caractere albe la tastare .#include<stdio.h>#include<conio.h>void main(){ char nume[51] ;

char prenume[51];clrscr();

//citirea celor două şiruri de caracterescanf("%s%s",nume,prenume); //afişarea lor separate prin tabprintf("%s\t%s\n",nume,prenume); getch();

}Observaţie: Reamintim că, în lipsa unui scanset adecvat, funcţia scanf() nu poate citi şiruri de caractere ce conţin spaţii. Astfel, primul specificator %s va citi caracterele tastate până la primul spaţiu şi le va stoca în variabila nume. Deasemenea, funcţia scanf() lucrează în mod bufferat, adică preia datele nu direct de la tastatură ci din zona tampon (buffer-ul) asociată acesteia. Bufferul de intrare se goleşte atunci când se citesc toate caracterele până la întâlnirea caracterului newline (generat la apăsarea tastei Enter). Astfel, al doilea specificator %s va citi restul caracterelor aflate în buffer după spaţiu şi le va stoca în variabila prenume. Această citire se face corect numai dacă datele de intrare sunt tastate conform cerinţelor din program (pe aceeaşi linie separate prin spaţii).

6


10. Citiţi un întreg zecimal de cel mult 4 cifre şi afişaţi-l ca întreg în baza 10, 8 şi 16. Cele trei numere vor fi afişate pe o linie nouă separate printr-un tabulator.#include<stdio.h>#include<conio.h>void main(){ int n;

clrscr(); //citirea unui întreg de 4 cifre

scanf("%4d",&n); //afişarea valorii în cele 3 baze printf("%d\t%o\t%x\n",n,n,n);

getch();}

11. Citiţi 4 cifre zecimale şi afişaţi-le precedate de câte un spaţiu fiecare .#include<stdio.h>#include<conio.h>void main(){ int i1,i2,i3,i4;

clrscr(); //citirea a patru întregi de câte o cifră fiecare

scanf("%1d %1d %1d %1d",&i1,&i2,&i3,&i4); //afişarea valorilor precedate de spatii

printf("%2d%2d%2d%2d",i1,i2,i3,i4);getch();

}

12. Citiţi o dată calendaristică tastată sub forma zzllaa (două cifre pentru zi, două cifre pentru lună şi două pentru an). Afişaţi data respectivă sub forma 19aallzz.#include<stdio.h>#include<conio.h>void main(){ int zi,luna,an;

clrscr();//citirea celor 3 întregi de câte două cifre

//fiecarescanf(“%2d%2d%2d”,&zi,&luna,&an);//afişarea celor 3 întregi precedaţi de 19, pe câte

//un câmp de 2 caractere cadrat la dreapta şi //completat cu zerouri

printf(“19%02d%02d%02d\n”,an,luna,zi);getch();

}

B. Probleme propuse

1. Citiţi un caracter şi afişaţi-l într-un câmp de 3 caractere cadrat la stânga, câmpul fiind precedat şi urmat de câte un asterisc .

2. Pentru o dată calendaristică se introduce de la tastatură un şir care are forma: "zz.ll.aa". Scrieţi un program care citeşte o dată în acest format şi apoi afişează pe câte o linie ziua, luna şi anul citite.

3. Citiţi un text de 16 caractere şi afişaţi-l pe ecran, pe câte o linie nouă, folosind următorii specificatori de format : %s, %20s, %-20s, %10s, %10.5s, %-10.5s. Câmpul în care se afişează textul este precedat şi urmat de un asterisc.

4. Citiţi un număr întreg cu maxim 9 cifre şi afişaţi-l pe ecran folosind specificatorii de format : %ld, %lo, %lx, %lX, %15ld, %-15ld, %015ld. Câmpul va fi precedat şi urmat de un asterisc.

5. Citiţi inversul lui PI cu 14 zecimale (0.31830988618379) şi afişaţi-l folosind următorii specificatori de format : %.15f, %.14f, %.13f, %.12f, %.11f, %.10f, %f, %.15e, %.14e, %.13e,

7


%.12e, %.11e, %.10e, %e. Pe fiecare linie se vor tipări câte trei valori separate prin câte două spaţii.

6. Citiţi numărul 1234567890 şi afişaţi-l cu exponent .7. Afişaţi numărul float f=123.672 folosind specificatorii : %10f, %10.1f, %10.0f, %e, %.1Ef, %g,

%10.1g, %10.0g, fiecare valoare pe câte o linie , câmpul fiind precedat şi urmat de un asterisc.

8. Citiţi un întreg zecimal de cel mult 9 cifre şi afişaţi-l ca întreg în baza 10, 8 si 16 . Cele trei valori vor fi afişate pe o linie nouă separate printr-un tabulator .

9. Citiţi 4 cifre zecimale şi afişaţi-le urmate fiecare de câte un zero.10. Citiţi o succesiune de 4 cifre care reprezintă o zi din luna octombrie pe primele două cifre şi

anul pe ultimile două (zzaa). Afişaţi data calendaristică respectivă sub forma : 19aa Octombrie zz .

11. Scrieţi un program care, utilizând un scanset adecvat, să permită citirea şi afişarea şirurilor de caractere care conţin spaţii.

12. Scrieţi un program care, utilizând un scanset adecvat, să permită citirea şirurilor de caractere care nu conţin cifre zecimale, respectiv litere mici.

8


Cap.2 Operatorii limbajului C


1. Ţinând seama de regulile de precedenţă pentru calculul expresiilor, indicaţi rezultatele pe care le afişează programul următor, explicaţi obţinerea acestor rezultate şi apoi verificaţi rulând programul.#include<stdio.h>#include<conio.h>void main(){

int x=2, y=7, z,u;clrscr();

u=x*(y-2)%3; printf("\n u=%d",u); z=u+=x*=y; printf("\n x=%d\ty=%d\tu=%d\tz=%d",x,y,u,z); x=-y*z%3+u; printf("\n x=%d",x); z=(x-y)*(u-x); printf("\n z=%d",z); getch();}

Rezolvare:Pentru prima expresie, mai întâi se efectuează scăderea, întrucât parantezele

au prioritate mai mare; se obţine valoarea 5; operaţiile de înmulţire şi împărţire cu rest au aceeaşi precedenţă şi se efectuează de la stânga la dreapta; se înmulţeşte x cu 5 şi după aceea se face împărţirea lui 10 cu 3, restul obţinut fiind 1.

În a doua expresie operatorii cu atribuiri se evaluează de la dreapta la stânga; mai întâi se înmulţeşte x cu y, x devenind 14 ; mai apoi se adună la u valoarea lui x, u devenind 15; în final valoarea lui u este atribuită lui z care devine astfel egal cu 15.

În a treia expresie operatorul unar minus schimbă semnul lui y întrucât are o precedenţă mai mare decât toate celelalte operaţii; se execută de la stânga spre dreapta înmulţirea şi împărţirea cu rest obţinându-se zero; ultima operaţie înainte de atribuire este adunarea; după atribuire x devine 15.

În ultima expresie se evaluează parantezele de la stânga la dreapta, x-y şi apoi u-x, apoi înmulţirea şi ultima operaţie este atribuirea, rezultatul fiind zero. Se afişează :

u=1; x=14 y=7 u=15 z=15; x=15; z=0

2. Având în vedere modul de evaluare a expresiilor de atribuire, să se indice rezultatele afişate de programul următor, să se explice aceste rezultate şi apoi să se verifice rulând programul.#include<stdio.h>#include<conio.h>void main(){

int a=1, b=2, c=3, d=4; clrscr(); d/=(a*=(b+=c)%3)-10; //1 printf("\n a=%d b=%d c=%d d=%d",a,b,c,d); a=1 , b=2, c=3, d=4; d/=a*=b+=c%3-10; //2 printf("\n a=%d b=%d c=%d d=%d",a,b,c,d); getch();}

Rezolvare:Pentru prima instrucţiune, se execută întâi b=b+c şi b devine 5, apoi b%3=2, apoi a=a*2 şi a

devine 2, apoi d=d/(2-10)=d/(- 8)=0. Valorile afişate sunt: a=2 b=5 c=3 d=0.Pentru a doua instrucţiune, se execută mai întâi b=b+c%3-10=2+0-10 şi b devine –8, apoi

a=a*(-8) şi a devine –8, apoi d=d/(- 8) şi d devine 0. Variabila c rămâne 3 şi se afişează: a=- 8 b=- 8 c=3 d=0

9


3. Programul următor ilustrează modalităţile de utilizare a operatorilor unari +,-,++,-- şi a operatorilor binari + şi -. Precizaţi rezultatele afişate de program, explicaţi aceste rezultate şi apoi verificaţi-le rulând programul.#include<stdio.h>#include<conio.h>void main(){

int a=1, b=10; clrscr(); printf("\n a+++b=%d",a+++b); //1 printf(" a=%d b=%d",a,b); a=1, b=10; printf("\n a+ ++b=%d",a+ ++b); //2 printf(" a=%d b=%d",a,b); a=1, b=10; printf("\n a +++b=%d",a +++b); //3 printf(" a=%d b=%d",a,b); a=1, b=10; printf("\n a+++ b=%d",a+++ b); //4 printf(" a=%d b=%d",a,b); a=1, b=10; printf("\n a++ +b=%d",a++ +b); //5 printf("\n a++-b=%d",a++-b); //6 printf(" a=%d b=%d",a,b); a=1, b=10; printf("\n a---b=%d", a---b); //7 printf(" a=%d b=%d",a,b); a=1, b=10; printf("\n a+++++b=%d", a+ + + + +b); //8 printf(" a=%d b=%d",a,b); a=1, b=10; printf("\n a++ + ++b=%d", a++ + ++b); //9 printf(" a=%d b=%d",a,b); getch();

}Rezolvare :

Aceşti operatori se grupează de la stânga la dreapta. Instrucţiunea (1), execută a+b, apoi a++ (postincrementare) şi se afişează:

a+++b=11 a=2 b=10Instrucţiunea (2) preincrementează b (operatorul de preincrementare este legat

explicit de b) şi apoi a+b. Se afişează: a+ ++b=12 a=1 b=11

Instrucţiunea (3), pentru că cei trei operatori + sunt legaţi de b, face gruparea lor de la stânga la dreapta astfel încât se calculează a+b şi apoi se postincrementează a ( ca la instrucţiunea 1). Se afişează:

a +++b=11 a=2 b=10Instrucţiunea (4) lucrează exact ca (3), cei trei operatori + fiind legaţi de a. Se

afişează: a+++ b=11 a=2 b=10

Instrucţiunea (5) se execută la fel ca (3) şi (4) operatorul de postincrementare fiind scris explicit, legat de a şi separat prin spaţiu de operatorul binar de adunare. Se afişează:

a++ +b=11Instrucţiunea (6) lucrează cu valorile obţinute după instrucţiunea (5), adică a=2 şi

b=10. Se execută întâi a-b, apoi a se postincrementează. Se afişează: a++-b=-8 a=3 b=10

Instrucţiunea (7) lucrează ca instrucţiunea (1), dar cu operatori de scădere şi postdecrementare. Întâi se execută a-b, apoi a--. Se afişează:

a---b=-9 a=0 b=10În cazul instrucţiunii (8), compilatorul nu poate stabili care operatori sunt de

incrementare şi care de adunare. Îi execută de la stânga la dreapta sub forma a+(+(+(+(+b))))=a+b. Cele două variabile nu îşi schimbă valoarea şi se afişează:

10


a+++++b=11 a=1 b=10În cazul instrucţiunii (9) operatorii de pre şi postincrementare sunt legaţi explicit de

variabile şi separaţi prin spaţii de operatorul binar de adunare. Se execută în ordine ++b, a+b, a++ şi se afişează:

a++ + ++b=12 a=2 b=11

4. Să se arate care sunt rezultatele pe care le afişează programul de mai jos şi să se argumenteze aceste rezultate pe baza regulilor de precedenţă. Să se verifice apoi rezultatele rulând programul.#include<stdio.h>#include<conio.h>void main(){

int x=3, y=7, z=9; clrscr(); printf("\n %d", x>y&&y>z); printf("\n %d", x<y&&y<z); printf("\n %d", x>y||x<z); printf("\n %d", !(x>y)); printf("\n %d", x==3); printf("\n %d", x==3&&y==7&&z==y+2); printf("\n %d", x!=y&&z!=y); getch();}Rezolvare:

Întrucât operatorii de comparare au precedenţe mai mari decât operatorii logici, se evaluează mai întâi expresiile relaţionale ale căror rezultate sunt 1 sau 0. După cum au atribuite valori, x nu este mai mare decât y şi y nu este mai mare ca z; cele două comparaţii au ca rezultat 0; operatorul && va conduce în final tot la rezultatul 0.

În a doua expresie ambele comparaţii sunt adevărate şi conduc fiecare la un rezultat 1, iar operatorul logic && conduce la valoarea 1 pentru expresie, valoare care se afişează.

În acelaşi mod se continuă evaluarea celorlalte expresii.

5. Având în vedere semnificaţia pe care o are compunerea diferiţilor operatori cu operatorul de atribuire, să se indice care sunt rezultatele afişate de programul de mai jos, apoi să se verifice aceste rezultate rulând programul.#include<stdio.h>#include<conio.h>void main(){

int x1,x2,x3,x4,x5,x6,x7,x8,x9; clrscr(); x1=x2=x3=x4=x5=x6=x7=x8=x9=17; x1+=2; printf("\n x1=%d",x1); x2-=2; printf("\n x2=%d",x2); x3*=2; printf("\n x3=%d",x3); x4/=2; printf("\n x4=%d",x4); x5%=2; printf("\n x5=%d",x5); x6<<=2; printf("\n x6=%d",x6); x7>>=2; printf("\n x7=%d",x7); x8+=++x8; printf("\n x8=%d",x8); x9+=--x9; printf("\n x9=%d",x9); getch();}Rezolvare : Se adaugă 2 la x1; se scade 2 din x2; se înmulţeşte x3 cu 2; se împarte x4 prin 2; în x5 se va afla restul împărţirii lui x5 prin 2; x6 se înmulţeşte cu 4 şi x7 se împarte la 4; x8 este incrementat cu 1 şi se adaugă lui însuşi, devenind 36; x9 este decrementat şi noua lui valoare, 16 se adaugă lui x9 devenind 32. Rezultatele tipărite de program sunt :

x1=19 x2=15 x3=34 x4=8 x5=1 x6=68 x7=4 x8=36 x9=32

11


6. Expresiile care apar în lista de parametri la apelul funcţiei printf() se evaluează înainte de apelarea funcţiei, după regulile de precedenţă cunoscute. Explicaţi rezultate afişate de programul următor şi apoi verificaţi aceste rezultate rulând programul.#include<stdio.h>#include<conio.h>void main(){

int a=1, b=3, c=5, d=7; clrscr(); printf("\n a<b==d>b este: %d",a<b==d>b); printf("\n (a<c)?d:b este: %d",(a<c)?d:b); printf("\n -a+b*c/d este: %d",-a+b*c/d); printf("\n a+d%%b+c este: %d",a+d%b+c); printf("\n b<d+c este: %d",b<d+c); printf("\n a==b+d==c+2 este: %d",a==b+d==c+2); printf("\n ++b * --c * d++ este: %d",++b*--c*d++); printf("\n a++ + ++b este: %d",a++ + ++b); printf("\n (a<<3)-++d%%b este: %d",(a<<3)-++d%b); printf("\n b+=c+d+a este: %d",b+=c+d+a); getch();}Rezolvare:

Se compară mai întâi a cu b, apoi d cu b; întrucât inegalităţile sunt adevărate, rezultatele comparării asignează celor două subexpresii valoarea 1; cele două valori 1 sunt comparate prin operatorul de egalitate şi expresia fiind adevărată se va tipări 1.

În a doua expresie se compară a cu c; rezultatul este 1, ceea ce determină tipărirea lui d.

În a treia expresie , mai întâi a devine -1, se înmulţeşte b cu c şi apoi se împarte la d; -1+2=1.

În a patra expresie, se calculează întâi d%b=7%3=1 şi apoi se fac adunările 1+1+5=7.

În a cincea expresie b=3 este într-adevăr mai mic decât d+c=12 şi se afişează valoarea expresiei relaţionale adică 1.

În a şasea expresie evaluarea se face de la stânga la dreapta şi a=1 este diferit de b+d=10, deci valoarea primei expresii relaţionale este 0. Apoi acest 0 este diferit de c+2=7 şi se afişează valoarea expresiei relaţionale adică 0.

Pentru a şaptea expresie prin decrementare b devine 4; prin decrementare c devine 4 ; 4*4*7=112 ; postincrementarea lui d are efect ulterior şi d devine 8.

În a opta expresie folosim valorile obţinute la paşii anteriori adică a=1 şi b=4. Întâi se preincrementează b (devine 5), apoi se adună cu a şi se afişează valoarea 6, apoi se postincrementează a care devine 2.

În a noua expresie folosim valorile obţinute la paşii anteriori adică a=2, d=8, b=5. Se preincrementează d (devine 9), apoi se afectuează d%b=9%5=4. Această valoare se scade din a<<3=2*23=16 şi se afişează 12.

În ultima expresie la valoarea lui b=5 se adună c=4, d=9 şi a=2 şi se afişează 20 care este şi noua valoarea a lui b.Rezultatele afişate sunt:

a<b==d>b este: 1(a<c)?d:b este : 7-a+b*c/d este : 1a+d%b+c este: 7b<d+c este: 1a==b+d==c+2 este : 0++b*--c*d++ este : 112a++ + ++b este : 6(a<<3)-++d%b este : 12b+=c+d+a este : 20

7. Operatorul condiţional se poate utiliza individual sau compus, chiar cu el însuşi. Explicaţi modul în care este folosit acest operator în programul următor pentru a determina maximul a trei numere întregi.#include<stdio.h>

12


#include<conio.h>void main(){

int a,b,c,d; clrscr(); printf("a,b,c="); scanf("%d %d %d",&a,&b,&c); d=a>b? a>c? a:c:b>c? b:c; //1 printf("\ maximul=%d",d); getch();}Rezolvare: Înstrucţiunea (1) are descrierea algoritmică următoare:

dacă a>batunci dac ă a>c atunci da altfel dc

sfarsit_dacaaltfel daca b>c atunci db altfel dc

sfarsit_dacasfarsit_daca

Evident, acesta este algoritmul de determinare a maximului dintre 3 valori.

8. Ţinând seama de regulile de precedenţă ale operatorilor pe biţi şi de semnificaţia acestora, să se indice care sunt rezultatele pe care le tipăreşte programul următor şi să se verifice apoi aceste rezultate rulând programul.#include<stdio.h>#include<conio.h>void main(){

int a=03, b=04, c=05, d=01; clrscr(); printf("\n ~a: %o",~a); //(1) printf("\n ~a: %d",~a); printf("\n aâ|d: %o",aâ|d); //(2) printf("\n aâ|d: %d",aâ|d); printf("\n a&c^b: %o",a&c^b); //(3) printf("\n a&c^b: %d",a&c^b); printf("\n a|b: %o", a|b); //(4) printf("\n a|b: %d", a|b); printf("\n a|b&c|d: %o",a|b&c|d); //(5) printf("\n a|b&c|d: %d",a|b&c|d); printf("\n a^b: %o", a^b); //(6) printf("\n a^b: %d", a^b); printf("\n ~a|~b: %o", ~a|~b); //(7) printf("\n ~a|~b: %d", ~a|~b); printf("\n a|(b|c)&d: %o",a|(b|c)&d); //(8) printf("\n a|(b|c)&d: %d",a|(b|c)&d); getch();}Rezolvare:Cele trei variabile sunt întregi cu semn scrise în baza 8 (încep cu cifra 0). Pentru evaluarea expresiilor vom considera tipul int reprezentat intern pe 2 octeţi. În cazul în care lucraţi cu int pe 4 octeţi, modul de evaluare se extinde pe 32 de biţi.

Pentru instrucţiunile (1), reprezentarea internă binară a lui a este 00000000 00000011, ~a=11111111 11111100 care în baza 8 (cu specificatorul %o) este 177774. Dacă folosim specificatorul %d, numărul zecimal corespunzător se calculează astfel: bitul de semn este 1, deci numărul este negativ, reprezentat în complement faţă de 2. Scădem din ~a=11111111 11111100 valoarea 1 şi obţinem 11111111 11111011, apoi negăm bit cu bit şi obţinem 00000000 00000100 care este 4 în baza 10. Numărul fiind negativ, se afişează –4.

13


Pentru instrucţiunile (2) evaluăm astfel: a^a=0, indiferent de valoarea lui a, iar 0|d=d indiferent de valoarea lui d. Cum d=1, se va afişa 1 cu ambii specificatori de format.

Pentru instrucţiunile (3) evaluăm astfel: întâi se evaluează a&c, adică (00000000 00000011)&(00000000 00000101)=00000000 00000001, adică 1 şi în baza 10 şi în baza 8. În continuare, se evaluează (00000000 00000001)^(00000000 00000100)=00000000 00000101 care este 5. Cu ambii specificatori de format se tipăreşte valoarea 5.

Pentru instrucţiunile (4) se evaluează a|b=(00000000 00000011)|(00000000 00000100)=00000000 00000111 care este 7 în ambele baze. Cu ambii specificatori de format se tipăreşte valoarea 7.

Pentru instrucţiunile (5) evaluarea se face astfel: întâi se evalueză b&c=(00000000 00000100)&(00000000 00000101)=00000000 00000100 adică 4. În continuare se evaluează a|4=(00000000 00000011)|(00000000 00000100)=00000000 00000111 adică 7. În final se evaluează 7|d=7|1=7. Cu ambii specificatori de format se afişează valoarea 7.

Pentru instrucţiunile (6), se procedează ca în exemplele anterioare şi se obţine a^b=00000000 00000111=7 care se afişează cu ambii specificatori de format.

Pentru instrucţiunile (7) evaluarea se face astfel: întâi se execută ~a=11111111 11111100 (vezi (1)), apoi se execută ~b=11111111 11111011 şi în final se execută (11111111 11111100)|(11111111 11111011)=11111111 11111111 care este un număr negativ pentru că are bitul de semn 1. Cu specificatorul de format %o se afişează 177777. În cazul specificatorului %d, valoarea se calculează astfel: scădem din valoarea binară anterioră 1 şi obţinem 11111111 11111110 care negat bit cu bit este 00000000 00000001 adică 1. Cum numărul este negativ, se va afişa –1.

Pentru instrucţiunile (8) se procedează astfel: se evaluează întâi b|c pentru că parantezele au prioritate maximă, şi obţinem 00000000 00000101=5. În continuare se execută 5&d=5&1=1. În final se execută a|1=3|1=3. Cu ambii specificatori de format se afişează valoarea 3.

9. Fie declaratia : int i,x,y; Să se verifice dacă utilizarea următoarelor expresii este corectă; argumentaţi răspunsul apoi verificaţi pe calculator, pentru diferite valori ale variablelor citite de la intrare. a) (i+1)++ b) i+++ 1 c) --x+y d) ++i++e) &x+1 f) &(x+1) g) -x&1Rezolvare:a) incorectă; (i+1) nu este o variabilă posibilă în stânga operatoruluib) este corectă; se efectuează întâi i+1 şi apoi i++, fiind o postincrementarec) este corectă; se decrementează x şi apoi se adună cu yd) incorectăe) corectă; rezultatul este o adresă mai mare cu sizeof(x)f) incorectă; x+1 nu este nume de variabilăg) corectă

10. Precizaţi efectul operaţiilor :int x,y,z; scanf("%d",&x); y-=(z=x,x<0);

Justificaţi răspunsul, apoi verificaţi pe calculator. Pentru obţinerea rezultatului erau necesare parantezele rotunde ?Rezolvare:Instrucţiunea de atribuire realizează, în ordine, următoarele operaţii :- z=x- x<0 , cu rezultat 0 sau 1- y=y-(x<0) , cu rezultat numericFără paranteze, se realizează,în ordine, următoarele operaţii :- z=x- y=y-x- x<0În concluzie, pentru obţinerea rezultatului corect, este necesară folosirea parantezelor rotunde.

11. Fie declaraţia : unsigned n=359; Care din expresiile următoare determină octetul inferior al variabilei n ? Justificaţi răspunsul pentru fiecare caz în parte (cu ajutorul reprezentării interne) şi apoi verificaţi fiecare variantă rulând pe calculator.a) n%256 b) n>>4 c) n & 0xFFd) (n<<4)>>4 e) n>>8 f) (n<<8)>>8

14


Rezolvare: Expresia a) foloseşte teorema împărţirii cu rest şi obţinem 359%256=93 deci este

corectă, pentru că restul împărţirii unui număr natural la 256 este o valoare din mulţimea 0...255, deci chiar octetul inferior al acestuia.

Expresia b) deplasează reprezentarea internă a lui n care este 00000001 01011101 cu 4 poziţii spre dreapta. Obţinem valoarea 00000000 00010101 care este în baza 10 egală cu 21 deci este greşită.

Expresia c) foloseşte o mască pe biţi egală cu 00000000 11111111 şi care cu operatorul & extrage exact octetul inferior al variabilei n. Într-adevăr, 00000001 01011101 & 00000000 11111111=00000000 01011101=93 adică octetul inferior al lui n, deci este corectă.

Expresia d) deplasează întâi reprezentarea internă a lui n cu 4 poziţii spre stânga şi obţinem 00010101 11010000, apoi deplasează acest număr cu 4 poziţii spre stânga şi obţinem 0000001 01011101 adică valoarea n de la care am plecat. În concluzie este greşită.

Expresia e) deplasează reprezentarea internă a lui n cu 8 poziţii spre stânga, adică elimină complet octetul inferior şi obţinem 00000000 00000001, deci este greşită.

Expresia f) deplasează reprezentarea internă a lui n cu 8 poziţii spre stânga, eliminând octetul superior, şi obţinem 01011101 00000000, apoi deplasează această valoare înapoi cu 8 poziţii spre dreapta şi obţinem 00000000 01011101 adică chiar octetul inferior al lui n, deci este corectă.

12. Evaluaţi rezultatul şi corectitudinea următoarelor secvenţe de operaţii, apoi verificaţi răspunsul cu ajutorul calculatorului :

int i=1, j=2, k=-7;double x=0.0, y=2.5;

a) -i-5*j>=k+1 b) 3<j<5 c) i+j+k==-2*jd) x/!!y e) x && i || j-3Rezolvare:a) corectă : E=0b) corectă : E=1c) corectă : E=1d) corectă : E=0 (face !y=0; !0=1; x/1=0/1=0 )e) corectă : E=1 (face x&&i=0; j-3=-1; 0||-1=1)

13. Să se determine care din următoarele expresii sunt corecte. Argumentaţi răspunsul şi apoi verificaţi fiecare variantă cu ajutorul calculatorului.a) z=x++==4 || y--<5;b) a=x==y==z;Rezolvare:a) corect : face , în ordine, z=x==4||y<5; x++; y--;b) corect : face a=(x==y)==z;

14. Să se stabilească valoarea şi tipul expresiilor de mai jos, apoi să se verifice rezultatele cu ajutorul calculatorului:int i,j,k; float fa,fb,fc; double da,db,dc;long la,lb; unsigned ua,ub; char ca;Valorile iniţiale ale variabilelor :i=10; j=5; k=4; fa=10.0; fb=5.0; da=10.0; db=5.0; la=1000000000; ua=40000; ca=’3’;Operaţiile:a) i+j*k g) i*fa/4 m) la/i t) k*10+ca-‘0’b) i/k+j h) fa/4 n) la/fb u) fc=fa/fbc) –i-j+20 i) 4/fa o) la/db v) dc=da/dbd) i*-k+100 j) i*da-k p) ua/la x) dc=la*dae) i/4.0 k) da/4 r) i+ca y) dc=(double)la*uaf) i/k-8.0 l) la-i*1000s) ca-‘0’ z) ub=((double)la*ua)/1e9Expresiile de mai jos au rezultate eronate. Să se motiveze acest fapt.er1) i=ua er2) la=1e20 er3) ua*2 er4) ca*ua er5) ca*la

Rezolvare:

15


Reamintim că în C tipul unei expresii este dat de cel mai mare tip (ca domeniu de valori şi reprezentare internă) care intervine în expresie.a) tipul int , valoarea 30b) tipul int , valoarea 7c) tipul int , valoarea 5d) tipul int , valoarea 60e) tipul float , valoarea 2.5f) tipul float , valoarea –6.0g) tipul float , valoarea 25.0h) tipul float , valoarea 2.5i) tipul float , valoarea 0.4j) tipul double , valoarea 96.0k) tipul double , valoarea 2.5l) tipul long , valoarea 999990000m) tipul long , valoarea 100000000n) tipul float , valoarea 200000000.0o) tipul double , valoarea 200000000.0p) tipul long , valoarea 0r) tipul int , valoarea 61s) tipul char , valoarea ‘3’t) tipul int , valoarea 43u) tipul float , valoarea 2.0v) tipul double , valoarea 2.0x) tipul double , valoarea 10000000000.0y) tipul double , valoarea 40000000000000.0z) tipul unsigned , valoarea 40000În privinţa expresiilor eronate, toate depăşesc domeniul de reprezentare corespunzător tipului.

15. Să se depisteze erorile existente în expresiile de mai jos, să se argumenteze şi să se verifice cu ajutorul calculatorului.a) a+b~(a+c) b) ((a+)b*c)*3c) ~a=b+cd) a<=be) a|(~b||^d)<x Rezolvare:a) ~ este operator unarb) + este operator binarc) ~a nu este nume de variabilăd) corect e) ^ este operator binar

B. Probleme propuse

1. Fie definiţiile :unsigned m=0xF0F , n=0xF0F0;char format[]="\n n=%4x";

Să se precizeze care vor fi valorile afişate după fiecare dintre următoarele operaţii, apoi să se verifice răspunsurile cu ajutorul calculatorului.a) printf(format,m);b) printf(format,n);c) printf(format,~m);d) printf(format,~n);e) printf(format,m|n);f) printf(format,m&n);g) printf(format,m^n);

2. Realizaţi cu ajutorul operatorului condiţional "?" şi/sau a operaţiilor de atribuire următoarele operaţii. Pentru fiecare scrieţi un program, valorile variabilelor care intervin fiind citite de la tastatură.

16


a) determinarea valorii absolute a unui număr real xb) determinarea minimului în valoare absolută a două numere reale a şi bc) determinarea maximului a trei numere întregi a, b şi cd) y=2x3-8x2+7x-1e) y=(ax+b)/(cx+d)f) a=max(x+y,x-y)g) m=max(3x2+1 ,6x-20)h) x=1,5a3-2,8a2+3,7a-1i) x=a*b*c-(a-b)(a-c)+(b-c)j) dacă (x+y)!=0 atunci z=x/(x+y) altfel z=0k) y=|2x+10|l) dacă x>y şi x>z atunci u=v , altfel u=v/2m) dacă x>y sau x>z, atunci p=a+b, altfel p=a-bn) dacă nici una din condiţiile i>j,i>k,i>n nu are loc, atunci x=a, altfel x=bo) dacă c are ca valoare codul ASCII al unui caracter alb (spaţiu sau tab), atunci i se

măreşte cu 1, altfel se micşorează cu 1p) dacă a>b>1 şi a<10, atunci x=a/b, altfel x=100q) dacă c are ca valoare un cod ASCII diferit de codul caracterelor albe, atunci i=x+y, altfel

i=x-yr) dacă valorile variabilelor a,b şi c pot reprezenta lungimile laturilor unui triunghi, atunci x

are ca valoare perimetrul acestui triunghi, altfel are valoarea 0.

3. Sa se determine valorile expresiilor de mai jos, apoi să se verifice rezultatele cu ajutorul calculatorului:

int i==0xabcd, j; unsigned ua=0xabcd;a)i>>3e)-~i g)~-!im)~0<<8 l)ua>>1&ib)i<<1f)~-i h)j=i^i m)~0>>4 c)ua<<1|Ii)~i n)!~-id)j=++~i j)ua<<1 o)ua<<1^ie)-i k)~!-i p)j=~i++f)ua>>3

4. Scrieţi un program care citeşte doi întregi de la intrarea standard şi afişează media lor aritmetică cu 2 zecimale.

5. Scrieţi un program care citeşte două numere întregi de la intrarea standard şi afişează 1 dacă suma celor două numere este nenegativă şi 0 în caz contrar.

6. Scrieţi un program care citeşte două numere reale simplă precizie de la intrarea standard şi afişează valoarea 2 dacă produsul numerelor citite este mai mare decât suma lor şi 1 în caz contrar.

7. Să se scrie un program care afişează valoarea 1 dacă primul număr citit de la tastatură este pătratul celui de-al doilea număr citit de la tastatură şi 0 în caz contrar. Numerele care se citesc sunt întregi fără semn.

8. Să se scrie un program care citeşte de la intrarea standard un întreg şi afişează 1 dacă întregul respectiv aparţine intervalului [-1000,1000] şi 0 în caz contrar.

9. Să se scrie un program care citeşte un întreg de la intrarea standard şi afişează 1 dacă este multiplu de 4 şi 0 în caz contrar.

10. Să se scrie un program care citeşte un întreg şi afişează valoarea 1 dacă numărul respectiv este multiplu de 4, dar nu este multiplu de 100.

11. Să se scrie un program care citeşte un întreg de la intrarea standard şi afişează 1 dacă numărul citit este multiplu de 4 şi nu este multiplu de 100 sau este multiplu de 400, şi 0 în caz contrar.

12. Să se scrie un program care citeşte valoarea lui x, calculează şi afişează valorile expresiilor: x10, x20, x40. Pentru a calcula puterea folosim funcţia putere care are prototipul double pow(double a,double b) în fişierul header math.h şi returnează ab.

13. Scrieţi un program care citeşte valoarea variabilei double x, calculează valoarea expresiei 3,5x2+4,6x+0,8 şi afişează partea întreagă a valorii expresiei respective.

14. Să se scrie un program care citeşte valoarea variabilei double x, calculează şi afişează valoarea expresiilor: 7[x]*[x]-3[x]+10 şi 7(x-[x])2-3(x-[x])+10, unde [x] notează partea întreagă a lui x.

15. Să se scrie un program care citeşte un număr întreg diferit de 0, îl atribuie variabilei n şi afişează cu 15 zecimale valoarea expresiei (n-1)/n.

17


16. Să se citescă un întreg în variabila x şi să se afişeze valoarea expresiei x3+32145x+1. Întrucât valorile pot depăşi limitele valorilor întregi, programul va realiza calculele în virgulă flotantă dublă precizie.

17. Să se scrie un program care citeşte două numere întregi şi afişează maximul dintre ele.18. Să se scrie un program care citeşte două numere, primul întreg iar celălalt double, şi afişează

maximul dintre ele.19. Să se scrie un program care citeşte doi întregi şi afişează maximul dintre valorile lor absolute.20. Să se scrie un program care citeşte valoarea variabilei x şi afişează valoarea funcţiei f(x)

definită ca mai jos:f(x)=3x2+7x-10 pentru x<0f(x)=2 pentru x=0f(x)=4x2-8 pentru x>0

21. Să se scrie un program care citeşte trei numere întregi şi afişează maximul dintre ele.22. Să se scrie un program care citeşte valoarea lui x de tip double şi calculează valoarea

funcţiei f(x) definită ca mai jos: f(x)=(3x8+2x4-x2+10)/(3x8+2x4-x2-10) dacă abs(3x8+2x4-x2-10)>=EPS f(x)=1 altfelunde EPS=1e-10 şi abs este funcţia modul cu prototipul în math.h.

18


Cap.3 Structuri de control

3.1 Structura secvenţială şi alternativă


1. Să se calculeze şi să se afişeze media aritmetică a două numere reale citite de la tastatură.#include<stdio.h>#include<conio.h>void main(){

float a,b,ma;printf("primul numar: "); scanf("%f",&a);printf("al doilea numar: "); scanf("%f",&b);ma=(a+b)/2;printf("media aritmetica=%.2f\n",ma);getch();

}

2. Să se interschimbe valorile a două variabile întregi citite de la tastatură.#include<stdio.h>#include<conio.h>void main(){

int a,b,aux;printf("primul numar: "); scanf("%d",&a);printf("al doilea numar: "); scanf("%d",&b);//folosim regula celor trei pahareprintf("\ninitial a=%d\tb=%d\n",a,b);aux=a; a=b; b=aux;printf("\ndupa interschimbare a=%d\tb=%d\n",a,b);getch();

}

3. Scrieţi un program care stabileşte relaţia de ordine dintre două numere reale citite de la tastatură.#include<stdio.h>#include<conio.h>void main(){

float a,b;printf("primul numar: "); scanf("%f",&a);printf("al doilea numar: "); scanf("%f",&b);if(a<b)

printf("\na<b\n");else

if(a==b)printf("\na=b\n");

elseprintf("\na>b\n");

getch();}

4. Se citesc trei numere întregi a,b,c. Să se tipărească maximul dintre ele folosind doar două comparaţii.#include<stdio.h>#include<conio.h>void main()

19


{int a,b,c,max;printf("numarul a="); scanf("%d",&a);printf("numarul b="); scanf("%d",&b);printf("numarul c="); scanf("%d",&c);//presupunem că a este maximulmax=a;//comparăm cu b si c şi actualizăm maximulif(max<b)

max=b;if(max<c)

max=c;printf("\n\tmaximul=%d\n",max);getch();

}

5. Să se rezolve ecuaţia de gradul unu ax+b=0 pentru coeficienţii a,b reali citiţi de la tastatură.#include<stdio.h>#include<conio.h>void main(){

double a,b,x;printf("coeficientul a="); scanf("%lf",&a);printf("coeficientul b="); scanf("%lf",&b);if(a) //coeficientul lui x nenul;soluţie unică{

x=-b/a;printf("\n\tx=%g\n",x);

}else

if(b)printf("\n\tecuatia nu admite

solutie\n");else

printf("\n\tecuatie nedeterminata, infinitate de solutii\n");

getch();}

6. Să se calculeze valoarea absolută a unui număr real citit de la tastatură.#include<stdio.h>#include<conio.h>void main(){

float x,abs;printf("numarul real x="); scanf("%f",&x);if(x<0)

abs=-x;else

abs=x;printf("\n\tvaloarea absoluta este %.3f\n",abs);getch();

}

7. Să se calculeze valoarea expresiei E= A+B, dacă C>=0

A-B, dacă C<0 unde A,B,C sunt trei variabile întregi citite de la tastatură.

#include<stdio.h>#include<conio.h>void main(){

20


int a,b,c,e;printf("valoarea A="); scanf("%d",&a);printf("valoarea B="); scanf("%d",&b);printf("valoarea C="); scanf("%d",&c);if(c>=0)

e=a+b;else

e=a-b;printf("\n\tE=%d\n",e);getch();

}

8. Să se calculeze valoarea funcţiei f(x)= x2, dacă x<0

2x+1, dacă x>=0unde valoarea reală a lui x se citeşte de la tastatură#include<stdio.h>void main(){

double x,f;printf("x="); scanf("%lf",&x);if(x<0)

f=x*x;else

f=2*x+1;printf("\n\tf(x)=%.4lf\n",f);

}

B. Probleme propuse

1. Cunoscând numărul natural n să se calculeze suma 1+2+3+...+n.2. Cunoscând k şi n (k<=n) numere naturale, să se calculeze suma k+(k+1)+...+n.3. Să se determine ultima cifră a sumei x+y, unde x şi y sunt numere naturale date de la

tastatură.4. Se citesc de la tastaură două numere naturale nenule. Să se calculeze media aritmetică,

media geometrică şi media armonică a celor două numere cu trei zecimale.5. Se consideră a,b,c trei variabile de tip real ale căror valori se citesc de la tastatură. Se cere să

se interschimbe circular de la stânga la dreapta valorile lor şi apoi să se afişeze. Exemplu: pentru a=2,b=17,c=4.3, după interschimbare avem a=4.3, b=2, c=17.

6. Să se determine ultimele două cifre ale produsului a*b, pentru a şi b numere întregi cu maxim cinci cifre fiecare citite de la tastatură.

7. Să se rezolve ecuaţia de gradul doi ax2+bx+c=0 pentru coeficienţii reali a,b,c citiţi de la tastatură.

8. Se citesc patru numere întregi oarecare. Să se verifice dacă ele alcătuiesc o mulţime în sens matematic, adică valorile sunt distincte.

9. Să se rezolve sistemul de ecuaţii cu coeficienţi realiax+by=cdx+ey=f

pentru a,b,c,d,e,f numere reale oarecare date.10. Să se calculeze valoarea expresiei E=A+1/B pentru valorile reale A,B citite de la tastatură.11. Să se calculeze valoarea expresiei

E= A+B+C dacă C<=-1 C/(A+B) dacă –1<C<1 (A+B)/C dacă C>=1

pentru A,B,C numere întregi citite de la tastatură.12. Să se calculeze valoarea expresiei E=A2/(A2+B)1/2, unde puterea ½ înseamnă radical ordin

doi, iar A şi B sunt numere reale citite de la tastatură.13. Să se calculeze valoarea expresiei P(x)=a4x4+a3x3+a2x2+a1x+a0, unde a4,a3,a2,a1,a0 şi x sunt

numere întregi citite de la tastatură (atenţie la depăşirea limitelor valorilor întregi).

21


14. Dându-se două numere întregi a şi b, a>b, testaţi dacă cele două numere se divid. În caz afirmativ afişaţi un mesaj, în caz contrar afişaţi câtul şi restul împărţirii lui a la b.

15. Se citesc trei numere întregi a,b şi c. Să se afişeze numerele în ordine crescătoare.16. Fiind date numere reale a,b,c,d afişaţi cel mai mic dintre ele.17. Fie a,b şi c salariile a trei persoane. Să se precizeze câte dintre acestea sunt cel puţin egale

cu o valoare dată x reprezentând salariul mediu pe economie.18. Citindu-se o literă mică, să se precizeze dacă aceasta este vocală sau consoană.19. Pe baza datei curente exprimată prin trei valori naturale nenule (zi,lună,an), să se calculeze

data zilei următoare.20. Se citesc trei numere naturale nenule a,b,c. Să se verifice dacă cele trei valori pot fi laturile

unui triunghi şi, în caz afirmativ, să se calculeze aria lui cu formula lui Heron. De asemenea să se specifice şi dacă este un triunghi particular (isoscel sau echilateral).

21. Să se determine ultima cifră a numărului 2x, pentru x număr natural dat.22. Folosind o singură comparaţie, să se verifice dacă trei numere naturale cu cel mult trei cifre

fiecare sunt pitagoreice. Se va afişa un mesaj corespunzător.23. Se citeşte de la tastatură un număr natural cu exact patru cifre. Să se verifice dacă numărul

este palindrom, adică citindu-l de la sfârşit spre început se obţine acelaşi număr.24. Se dau două numere de tip întreg. Să se verifice dacă ele sunt numere consecutive.25. Să se verifice dacă o fracţie a/b, pentru a şi b numere naturale nenule cu maxim 5 cifre, se

simplifică prin k. În caz afirmativ se va afişa şi fracţia simplificată. Numerele a,b,k se citesc de la tastatură în această ordine.

3.2 Structura repetitivă (iterativă)


1. Să se calculeze suma S=1+2+....+n, respectiv produsul P=1*2*...*n pentru n număr natural nenul citit de la tastatură.#include<stdio.h>#include<conio.h>void main(){

int n,s=0,i;double p=1; //n! poate depăşi limitele întregiprintf("n="); scanf("%d",&n);for(i=1;i<=n;i++){

s+=i;p*=i;

}printf("\n\tsuma=%d\n",s);printf("\tprodusul=%.0lf\n",p);getch();

}

2. Să se calculeze media aritmetică a n valori întregi citite pe rând de la tastatură, unde n este un număr natural nenul dat.#include<stdio.h>#include<conio.h>void main(){

int n,x,s=0,i;double ma;printf("numarul de numere,n="); scanf("%d",&n);printf("\t Introduceti numerele intregi\n");for(i=1;i<=n;i++){

printf("a%d=",i); scanf("%d",&x);

22


s+=x;}ma=(double)s/n;

//cast-ul este necesar,în caz contrar se obţine//partea întreagă a mediei aritmetice prin

//împărţirea a 2 numere întregiprintf("\n\tmedia aritmetica=%g\n",ma);getch();

}

3. Să se realizeze înmulţirea a două numere întregi a şi b date de la tastatură, prin adunări repetate.#include<stdio.h>#include<conio.h>void main(){

int a,b;double p=0;

//produsul poate depăşi limitele întregiprintf("a="); scanf("%d",&a);printf("b="); scanf("%d",&b);//folosim relaţia a*b=a+a+.....+a, de b orifor(int i=1;i<=b;i++) p+=a;printf("\n\t%d * %d = %g\n",a,b,p);getch();

}

4. Fiind dată funcţia f:NN, f(n)=n+1, dacă n este par, respectiv f(n)=n-1, dacă n este impar, să se calculeze valorile funcţiei pentru n=1,2,…,10.#include<stdio.h>#include<conio.h>void main(){

int n=10,i;printf("\nValorile functiei sunt:\n");for(i=1;i<=n;i++)

if(i&1) //i este imparprintf("\tf(%d)=%d\n",i,i-1);

elseprintf("\tf(%d)=%d\n",i,i+1);

getch();}

5. Să se determine şi să se afişeze divizorii proprii ai unui număr natural nenul n dat de la tastatură.#include<stdio.h>#include<conio.h>void main(){

int n,i;printf("numarul natural nenul,n="); scanf("%d",&n);//divizorii proprii ai lui n se găsesc în mulţimea

//{2,3,...,[n/2]}printf("\n\tDivizorii proprii ai lui %d

sunt:\n\n",n);for(i=2;i<=n/2;i++)

if(!(n%i)) //echivalent cu n%i==0printf("%d ",i);

printf("\n");getch();

}

23


6. Se defineşte şirul lui Fibonacci (legea creşterilor organice) astfel:F(n)= 0, dacă n=0 1, dacă n=1

F(n-1)+F(n-2), dacă n>=2adică termenii şirului sunt 0,1,1,2,3,5,8,13,21,....Să se afişeze primii n termeni ai şirului pentru n natural nenul citit de la tastatură.#include<stdio.h>#include<conio.h>void main(){

int n,a,b,c,i;printf("numarul de termeni,n="); scanf("%d",&n);a=0; //primul termenb=1; //al doilea termenprintf("\n\t Termenii sirului Fibonacci sunt:\n");printf("0 1 ");for(i=2;i<=n;i++){

c=a+b; //următorul termen egal cu suma //precedenţilor 2

a=b; b=c;printf("%d ",c);

}printf("\n");getch();

}

7. Se citesc pe rând n numere reale nenule (n natural nenul dat). Să se afişeze media aritmetică a câte două numere citite succesiv.

Observaţii:Pentru a calcula media aritmetică avem nevoie la fiecare pas de două valori: valoarea citită la pasul anterior şi valoarea citită la pasul curent. Vom memora cele două valori în două variabile x şi, respectiv, y. Pentru a avea valoarea y disponibilă pentru calculul următoarei medii, înainte de a trece la pasul următor vom transfera această valoare în x. Prima valoare din cele n se citeşte în variabila x în afara ciclului de calcul efectiv al mediilor.


int n,i;float x,y;printf("numarul de valori reale,n=");

scanf("%d",&n);printf("\n\t Introduceti %d valori reale:\n",n);printf("x1="); scanf("%f",&x); //primul numărfor(i=2;i<=n;i++){

printf("x%d=",i); scanf("%f",&y);//y este numărul curentprintf("\t media=%.3f\n",(x+y)/2);x=y;

}getch();

}

8. Se citesc pe rând n numere întregi (n natural nenul dat). Să se verifice dacă numerele apar sau nu în ordine crescătoare.

Observaţii:Se observă că un şir de valori este ordonat crescător dacă oricare două valori consecutive sunt bine ordonate, adică ak-1<=ak, pentru k=2,3,..,n. Este suficient ca o singură pereche de valori consecutive să nu respecte relaţia şi şirul nu mai este ordonat. Ca şi în problema precedentă, avem nevoie de valoarea citită la pasul precedent şi de valoarea citită la pasul curent, deci vom

24


lucra cu două variabile, x şi y. Deoarece toate cele n numere trebuiesc citite, indiferent dacă în final şirul este ordonat sau nu, vom folosi o variabilă sem iniţializată cu 1 pe care o vom schimba în 0 dacă găsim o pereche neordonată. Testând la sfârşit valoarea acestei variabile putem lua o decizie corectă asupra naturii şirului.


int n,i,x,y,sem=1;printf("numarul de numere,n="); scanf("%d",&n);printf("\n\tIntroduceti %d numere intregi\n",n);printf("x1="); scanf("%d",&x);for(i=2;i<=n;i++){

printf("x%d=",i); scanf("%d",&y);if(y<x) sem=0; //pereche neordonatăx=y;

}if(sem) //echivalent cu sem==1

printf("\n\tsirul este ordonat crescator\n");else

printf("\n\tsirul nu este ordonat crescator\n");

getch();}

9. Fie expresia P(x)=anxn+an-1xn-1+.....+a1x+a0. Să se calculeze valoarea expresiei pentru x real dat, n natural nenul dat şi numerele ai reale date, în două cazuri: valorile ai se introduc în ordinea an,an-1,....,a0 şi, respectiv în ordinea a0,a1,...,an.

Observaţii:Expresia de mai sus se numeşte polinom, x fiind argumentul polinomului. Gradul maxim al lui x (n în notaţia de mai sus) se numeşte gradul polinomului, iar numerele a0,a1,......,an se numesc coeficienţii polinomului. Există două metode diferite pentru calculul valorii polinomului în punctul x dat, după cum coeficienţii polinomului se citesc în ordinea crescătoare sau descrescătoare a puterilor lui x.a) Dacă coeficienţii se citesc în ordinea descrescătoare a puterilor lui x, adică în ordinea an,an-

1,....,a1,a0, facem următoarele observaţii:-dacă n=0, atunci P0(x)=an

-dacă n=1, atunci P1(x)=anx+an-1=P0(x)*x+an-1

-dacă n=2, atunci P2(x)=anx2+an-axn-1+an-2=(anx+an-1)*x+an-2=P1(x)*x+an-2

-generalizând, Pk(x)=Pk-1(x)*x+an-k, iar modul de calcul se numeşte „gruparea lui Horner”#include<stdio.h>#include<conio.h>void main(){

int n,k;double x,a,p=0;printf("gradul polinomului,n="); scanf("%d",&n);printf("valoarea x="); scanf("%lf",&x);printf("\n\tIntroduceti coeficientii in ordinea

descrescatoare a puterilor lui x\n");for(k=n;k>=0;k--){

printf("a%d=",k); scanf("%lf",&a);p=p*x+a;

}printf("\n\tP(%g)=%g\n",x,p);getch();

}b) Dacă coeficienţii se citesc în ordinea crescătoare a puterilor lui x, adică în ordinea a0,a1,...,an, facem următoarele observaţii:-dacă n=0, atunci P0(x)=a0

25


-dacă n=1, atunci P1(x)=a0+a1x=P0(x)+a1x-dacă n=2, atunci P2(x)=a0+a1x+a2x2=P1(x)+a2x2

-generalizând, Pk(x)=Pk-1(x)+akxk

Se observă că trebuie să calculăm puterile succesive ale lui x şi să le adăugăm la valoarea anterioară a polinomului. Pentru calculul acestor puteri vom folosi relaţia iterativă xk=xk-1*x.


int n,k;double x,a,p=0,q=1; //q=x0

printf("gradul polinomului,n="); scanf("%d",&n);printf("valoarea x="); scanf("%lf",&x);printf("\n\tIntroduceti coeficientii in ordinea

crescatoare a puterilor lui x\n");for(k=0;k<=n;k++){

printf("a%d=",k); scanf("%lf",&a);p+=a*q; q*=x; //următoarea putere a lui x

}printf("\n\tP(%g)=%g\n",x,p);getch();

}

10. Să se verifice dacă un număr natural nenul dat este „perfect”, adică este egal cu suma divizorilor săi proprii, inclusiv 1. Exemplu, 6=1+2+3 este număr perfect.

Observaţii:Determinăm pe rând divizorii proprii ai numărului şi-i însumăm plecând de la valoarea 1. Dacă suma obţinută este egală cu numărul dat, acesta este perfect.

#include<stdio.h>#include<stdio.h>void main(){

int n,d,s=1;printf("numarul n="); scanf("%d",&n);for(d=2;d<=n/2;d++)

if(!(n%d)) //echivalent cu n%d==0s+=d; //suma divizorilor

if(s==n)printf("\n\t%d este numar perfect\n",n);

elseprintf("\n\t%d nu este numar perfect\n",n);

getch();}

11. Se citesc pe rând n numere reale, n număr natural nenul dat. Să se determine numărul valorilor pozitive, numărul valorilor negative şi, respectiv, numărul valorilor nule introduse.#include<stdio.h>#include<conio.h>void main(){

int n,i,poz=0,neg=0,nule=0;double x;//poz este numărul valorilor pozitive citite//neg este numărul valorilor negative citite//nule este numărul valorilor egale cu 0 cititeprintf("numarul valorilor,n="); scanf("%d",&n);printf("\n\tIntroduceti %d numere reale\n",n);for(i=1;i<=n;i++){

printf("x%d=",i); scanf("%lf",&x);if(x>0)

26


poz++;else

if(!x)nule++;

elseneg++;

}printf("\nS-au introdus:\n");printf("\t%d valori pozitive\n",poz);printf("\t%d valori nule\n",nule);printf("\t%d valori negative\n",neg);getch();

}

12. Se citesc pe rând n numere reale. Să se determine minimul (maximul) dintre ele.Observaţii:Pentru a rezolva problema vom generaliza algoritmul de determinare a maximului/minimului dintre 3 valori.


int n,i;double x,max;printf("numarul valorilor,n="); scanf("%d",&n);printf("\n\tIntroduceti %d valori reale\n",n);printf("x1="); scanf("%lf",&x);max=x; //presupunem că prima valoare citită este maximăfor(i=2;i<=n;i++){

printf("x%d=",i); scanf("%lf",&x);if(max<x)

max=x; //actualizarea maximului}printf("\n\tmaximul=%g\n",max);getch();

}

13. Se citesc pe rând n numere reale. Să se determine media aritmetică a valorilor strict pozitive citite.#include<stdio.h>#include<conio.h>void main(){

int n,i,nr=0;double x,s=0;//nr=numărul valorilor strict pozitive citite//s=suma valorilor strict pozitive cititeprintf("numarul valorilor,n="); scanf("%d",&n);printf("\n\tIntroduceti %d valori reale\n",n);for(i=1;i<=n;i++){

printf("x%d=",i); scanf("%lf",&x);if(x>=0){

s+=x; nr++; //însumăm şi numărăm val. strict pozitive

}}if(nr) //am găsit valori strict pozitive

printf("\n\tmedia aritmetica=%g\n",s/nr);

27


elseprintf(“\nsirul nu contine valori strict

pozitive\n”);getch();

}

14. Fie funcţia f:R-{3}R, f(x)=(x2-7)/(x-3). Să se calculeze funcţia pentru mai multe valori ale lui x din domeniul de definiţie. Citirea datelor se încheie la introducerea valorii 3.

Observaţii:Deoarece numărul valorilor lui x este necunoscut, vom utiliza un ciclu cu test iniţial care încheie citirea şi afişarea la introducerea valorii 3 pentru care funcţia nu este definită.


double x,f;printf("x="); scanf("%lf",&x);while(x!=3){

f=(x*x-7)/(x-3);printf("\tf(%g)=%g\n",x,f);printf("x="); scanf("%lf",&x);

}getch();

}15. Fiind date două numere naturale nenule a şi b, să se determine câtul şi restul împărţirii întregi

a lui a la b prin scăderi repetate.Observaţii:Câtul împărţirii întregi a două numere reprezintă de câte ori „încape” împărţitorul în deîmpărţit. Ce rămâne din deîmpărţit în urma acestor scăderi repetate reprezintă restul.


int a,b,cat=0;do{

printf("a="); scanf("%d",&a);}while(!a); //nu poate fi nuldo{

printf("b="); scanf("%d",&b);}while(!b); //nu poate fi nulwhile(a>=b){

a-=b; //scădem împărţitorulcat++; //incrementăm câtul

}printf("\n\tcat=%d\trest=%d\n",cat,a);getch();

}

16. Fiind date două numere naturale nenule a şi b să se determine c.m.m.d.c. al lor prin două metode.

Observaţii:Unul din cei mai cunoscuţi algoritmi pentru rezolvarea acestei probleme este algoritmul lui Euclid. Pentru a înţelege modul de calcul vom considera două exemple:

a=72, b=6072%60=12; 60%12=0 => cmmdc=12 (ultimul rest nenul) a=45, b=2745%27=18; 27%18=9; 18%9=0 => cmmdc=9 (ultimul rest nenul)Prima variantă de program este:

#include<stdio.h>#include<conio.h>

28


void main(){

int a,b,rest;printf("a="); scanf("%d",&a);printf("b="); scanf("%d",&b);rest=a%b; //primul restwhile(rest) //cât timp rest diferit de 0{

a=b; b=rest;rest=a%b; //noul rest

}printf("\n\tcmmdc=%d\n",b); //ultimul rest nenulgetch();

}Pentru a doua variantă folosim metoda scăderilor repetate: din numărul mai mare scădem numărul mai mic până când cele două numere devin egale şi ambele reprezintă cmmdc.


int a,b;printf("a="); scanf("%d",&a);printf("b="); scanf("%d",&b);while(a!=b) //numerele diferă

if(a>b)a-=b;

elseb-=a;

printf("\n\tcmmdc=%d\n",a); //sau bgetch();

}

17. Fiind dat un număr n natural nenul să se verifice dacă este prim sau nu.Observaţii:Singurul număr par şi prim este 2. Pentru n=2 nu are sens să-i verificăm divizorii. Orice alt număr par diferit de 2 este compus fiind multiplu de 2. Numerele impare nu pot avea decât divizori impari din mulţimea 3,5,7,....Conform teoremei lui Euclid, dacă un număr natural nu are divizori proprii în mulţimea {2,3,….,√n} atunci este număr prim.

#include<stdio.h>#include<stdlib.h>#include<math.h>#include<conio.h>void main(){

int n,d;printf("numarul natural n="); scanf("%d",&n);if(n==2){

printf("\n\t2 este numar prim\n");exit(0); //oprirea forţată a programului

}if(!(n%2)) //număr par{

printf("\n\t%d este numar compus\n",n);exit(0);

}d=3;while(d<=(int)sqrt(n)+1)

if(!(n%d)) //n se divide cu d{

printf("\n\t%d este numar compus\n",n);exit(0);

29


}else

d+=2; //următorul divizor imparprintf("\n\t%d este numar prim\n",n);getch();

}

18. Fiind dat un număr n natural nenul cu maxim 8 cifre, să se determine suma cifrelor sale.Observaţii:Ultima cifră a unui număr natural este restul împărţirii numărului la 10. Pentru a determina următoarele cifre, trebuie să eliminăm această ultimă cifră din număr. Numărul obţinut prin eliminarea ultimei cifre este de fapt câtul împărţirii numărului la 10. Repetăm procedeul până când, prin împărţiri succesive, numărul devine egal cu 0, deci nu mai conţine nici-o cifră.


long n;int cifra,s=0; //s=suma cifrelorprintf("numarul natural nenul,n=");scanf("%ld",&n);do{

cifra=n%10; //ultima cifrăn/=10; //eliminăm ultima cifrăs+=cifra; //însumăm cifra

}while(n); //echivalent cu n!=0printf("\n\tsuma cifrelor=%d\n",s); getch();

}

19. Să se verifice dacă un număr natural nenul n dat este „palindrom”, adică citit de la dreapta la stânga şi de stânga la dreapta reprezintă aceeaşi valoare.

Observaţie:Pentru a verifica proprietatea, vom extrage pe rând cifrele numărului şi vom construi simultan numărul zecimal cu cifrele în ordine inversă. Dacă obţinem aceeaşi valoare, numărul iniţial este palindrom.


long n,t,inv=0;int cifra;printf("numarul natural nenul,n=");scanf("%ld",&n); t=n; //facem o copie a lui n//deoarece numărul devine egal cu 0do{

cifra=t%10; //extragem ultima cifrăt/=10; //o eliminăm din numărinv=inv*10+cifra; //o introducem în numărul invers

}while(t);if(n==inv)

printf("\n\t%d este palindrom\n",n);else

printf("\n\t%d nu este palindrom\n",n);getch();

}

20. Să se descompună un număr natural nenul n dat în factori primi, afişând pentru fiecare factor prim şi puterea corespunzătoare.

Observaţii:Algoritmul este cel folosit în aritmetică la descompunerea în factori primi. Se împarte numărul la 2 cât timp împărţirea se face exact. Numărul împărţirilor efectuate reprezintă puterea lui 2. Se

30


împarte apoi la 3 (dacă împărţirea se face exact), la 5 etc., până când, prin împărţiri repetate numărul devine egal cu 1.


int n,d=2,p;printf("numarul natural nenul,n=");scanf("%d",&n);printf("\n\t\tDescompunerea lui %d este:\n",n);do{

p=0; //puterea factorului prim dwhile(!(n%d)) //împărţirea la d se face exact{

n/=d; p++;}if(p) //puterea lui d este nenulă

printf("\tfactor=%d\tputerea=%d\n",d,p);

if(d==2)d=3;

elsed+=2;

}while(n>1);getch();

}

21. Să se treacă un număr natural nenul n cu maxim 8 cifre din baza 10 în baza p dată (2<=p<=9).

Observaţii:Algoritmul de trecere din baza 10 într-o altă bază este cel din aritmetică. Se împarte numărul la baza p obţinându-se un cât şi un rest. Câtul obţinut se împarte la p şi aşa mai departe, până când se obţine câtul 0. Se scriu resturile în ordine inversă, numărul rezultat fiind echivalentul în baza p.

Exemplu: n=47, p=247:2 => cat=23, rest=123:2 => cat=11, rest=111:2 => cat=5, rest=15:2 => cat=2, rest=12:2 => cat=1, rest=01:2 => cat=0, rest=1

Numărul obţinut este 1011112. Problema care apare este afişarea numărului obţinut pentru că resturile se obţin în ordinea inversă a scrierii lor în număr. În plus, pentru calculator, numărul afişat este văzut ca un număr zecimal obişnuit. Simultan cu determinarea resturilor trebuie să calculăm numărul zecimal care trebuie afişat. Pentru aceasta vom utiliza a doua metodă de calcul de la polinoame, deoarece resturile reprezintă coeficienţii unui polinom pentru x=10, coeficienţi furnizaţi în ordinea crescătoare a puterilor lui 10 (101111=1*100+1*101+1*102+1*103+0*104+1*105). Deoarece se pot obţine numere zecimale foarte mari vom folosi o variabilă double.


int n,p,rest;double baza=0, putere=1;//baza=numărul afişat în baza p//putere=100

printf("numarul in baza 10,n=");scanf("%d",&n);printf("baza p="); scanf("%d",&p);do{

rest=n%p; //restul împărţirii la baza pn/=p; //noul câtbaza+=rest*putere;

31


//compunerea numărului ce trebuie afişatputere*=10; //următoarea putere a lui 10

}while(n); printf("\n\tnumarul in baza %d este %g\n",p,baza);getch();

}

22. Se citeşte un număr scris în baza p dată (2<=p<=9). Să se determine echivalentul zecimal al numărului respectiv.

Observaţie:Folosim formula de calcul a echivalentului zecimal al unui număr dat într-o bază oarecare p: (cncn-

1….c1c0)p=c0*p0+c1p1+……+cnpn, unde ck, 0<=k<=n, reprezintă cifrele numărului scris în baza p. Se observă că trebuie să extragem pe rând cifrele numărului şi să le înmulţim cu puterile corespunzătoare ale bazei. Practic, se combină algoritmul pentru determinarea cifrelor unui număr cu cel pentru calculul valorii unui polinom în punctul x=p (baza) prin a doua metodă.


long n,baza=0,putere=1;int cifra,p;//baza este echivalentul zecimal//putere=p0

printf("baza p="); scanf("%d",&p);printf("numarul in baza p, n=");scanf("%ld",&n);do{

cifra=n%10; //extragem cifran/=10; //eliminăm cifrabaza+=cifra*putere; //introducem cifra în echiv. zecimalputere*=p; //următoarea putere a bazei p

}while(n);printf("\n\techiv. zecimal este %ld\n",baza);getch();

}

23. Să se treacă un număr scris în baza p dată (2<=p<=9), în baza q dată (2<=q<=9).Observaţii:Folosim metoda de la prob. 22 şi trecem numărul din baza p în baza 10, apoi metoda de la prob. 21 şi trecem numărul obţinut anterior din baza 10 în baza q.


long n,b10=0,putere=1,m=0;int p,q,cifra;//n este numărul dat in baza p//b10 este echivalentul său în baza 10//m este numărul echivalent în baza q//putere=p0 printf("baza initiala p="); scanf("%d",&p);printf("numarul initial in baza p, n=");scanf("%ld",&n);//trecem n în baza 10printf("baza q="); scanf("%d",&q);do{

cifra=n%10; //extragem cifran/=10; //eliminăm cifrab10+=cifra*putere; //introducem cifra în echiv. zecimalputere*=p; //următoarea putere a bazei p

32


}while(n);//trecem b10 în baza qputere=1; //puterile lui 10do{

cifra=b10%q; //obţinem restulb10/=q; //obţinem noul câtm+=cifra*putere; //compunem numărul de afişatputere*=10; //următoarea putere a lui 10

}while(b10);printf("\n\tnumarul in baza %d este %ld\n",q,m);getch();

}

24. Să se treacă un număr din baza 16 în baza 10. Citirea numărului hexazecimal se face cifră cu cifră, de la stânga la dreapta, până la apăsarea tastei Enter.

Observaţii:La scrierea unui număr în baza 16 se folosesc cifrele 0..9, literele ‘a’..’f’ sau ‘A’..’F’. Scrierea numărului fiind practic o combinaţie de litere şi cifre, vom trata numărul ca pe un şir de caractere. Fiecare caracter citit va fi transformat în valoarea lui zecimală pe baza codurilor ASCII asociate. Citirea făcându-se caracter cu caracter de la stânga spre dreapta, pentru a calcula echivalentul zecimal, vom folosi prima metodă de calcul de la polinoame, cifrele numărului constituind coeficienţii polinomului pentru x=16.

#include<stdio.h>#include<stdlib.h>#include<conio.h>void main(){

double b10=0; //echivalentul zecimalchar c;printf("\n\tIntroduceti un numar in baza 16

incheiat cu Enter\n");c=getchar();while(c!='\n') {

if(c>='0' && c<='9') b10=b10*16+c-'0';else

if(c>='a' && c<='f')b10=b10*16+c-'a'+10;

elseif(c>='A'&& c<='F')

b10=b10*16+c-'A'+10;else{

printf("\nnumar eronat!\n");

exit(0);}

c=getchar();}printf("\n\techiv. zecimal=%g\n",b10); getch();

}

25. Să se găsescă perechile de numere naturale a şi b care satisfac relaţia a+b=1000, 17 divide a şi 19 divide b.

Observaţii:Relaţia se mai poate scrie 17a1+19b1=1000. Cea mai mare valoare pentru a1 se obţine când b1=1 şi este n=[(1000-19)/17]. Formăm toţi multiplii de 17, adică a=i*17, pentru i=1,2,…n şi calculăm b ca diferenţa 1000-a. Dacă valoarea obţinută este multiplu de 19 am găsit o pereche de numere cu proprietatea cerută.


33


int a,b,n;void main(){

n=(1000-19)/17;for(int i=1;i<=n;i++){

a=i*17;b=1000-a;if(!(b%19)) printf("%d %d\n",a,b);

}getch();

}

26. Se citesc triplete de numere reale până la introducerea valorii 0. Să se determine pentru fiecare triplet de numere dacă constituie laturile unui triunghi, iar în caz afirmativ să se precizeze tipul acestuia.

Observaţii:Deoarece citirea se încheie la introducerea valorii 0, vom citi numerele unul câte şi unul şi, în cazul în care valoarea citită este 0, întrerupem execuţia programului cu funcţia exit(). Dacă valorile citite sunt nenule, ele formează un triunghi dacă fiecare este mai mică decât suma celorlalte două. Restul verificărilor folosesc proprietăţile triunghiurilor echilaterale, respectiv isoscele.


float a,b,c;while(1){ printf("a="); scanf("%f",&a); if(!a) exit(0); printf("b="); scanf("%f",&b); if(!b) exit(0); printf("c="); scanf("%f",&c); if(!c) exit(0); if(a<b+c && b<c+a && c<a+b)

{printf("numerele formeaza un

triunghi ");if(a==b && b==c)

printf("echilateral\n");else

if(a==b || b==c || c==a)printf("isoscel\n");

elseprintf("scalen\n");

}else

printf("numerele nu formeaza un triunghi\n");

}getch();

}

27. Se citesc perechi de numere naturale până când unul dintre ele este 0. Să se determine dacă cele două numere ale fiecărei perechi sunt prime între ele.

Observaţii:Două numere sunt prime între ele dacă au cmmdc=1. Pentru determinarea cmmdc folosim metoda scăderilor repetate. Pentru a păstra valorile iniţiale ale variabilelor a şi b, lucrăm cu copiile c şi d.

#include<stdio.h>

34



int a,b,c,d;printf("a,b="); scanf("%d %d",&a,&b);while(a && b) //ambele valori nenule{

c=a; d=b; while(c!=d)

if(c>d) c-=d; else d-=c;

if(c==1) printf("\t%d si %d sunt prime intre ele\n",a,b); else printf("\t%d si %d nu sunt prime intre ele\n",a,b); printf("a,b="); scanf("%d %d",&a,&b);}getch();

}

28. Să se determine toate perechile de numere gemene până la o anumită valoare n. Două numere sunt gemene dacă ambele sunt prime şi diferenţa lor în valoare absolută este 2.

Observaţii:Nu putem căuta numerele gemene decât printre numerele prime impare, cel mai mic astfel de număr fiind 3. Pentru fiecare pereche impară (a,b=a+2), cu b<=n, verificăm pe rând dacă cele două numere sunt prime. Fiind vorba de numere impare, care nu pot avea decât divizori impari, cele două for-uri folosite pentru căutarea divizorilor proprii au fost proiectate corespunzător.

#include<stdio.h>#include<math.h>#include<conio.h>void main(){

int n,a,b,ok1,ok2,i;printf("n="); scanf("%d",&n);a=3; b=a+2;while(b<=n){

ok1=1;for(i=3;i<=sqrt(a);i+=2)

if(!(a%i)){

ok1=0; break;}

if(ok1){

ok2=1;for(i=3;i<=sqrt(b);i+=2)

if(!(b%i)){

ok2=0; break;}

if(ok1 && ok2) printf("%d %d\n",a,b);}a=b; b=a+2;

} getch();}

29. Se citesc numere naturale, până la introducerea unui număr real. Să se calculeze suma numerelor citite, precum şi câtul şi restul împărţirii sumei numerelor la suma cifrelor sumei.

35


Obsevaţii:Nu putem citi numerele decât într-o variabilă reală datorită modului în care lucrează funcţia scanf (dacă folosim specificatorul %d şi introducem o valoare reală, ea este automat convertită la int prin trunchiere). Un număr real este întreg (nu are zecimale) dacă este egal cu partea lui întreagă. Pentru a verifica acest lucru folosim, de exemplu, funcţia ceil() care rotunjeşte un număr real la cel mai apropiat întreg prin lipsă. Suma numerelor reale fără zecimale citite o convertim apoi la tipul int folosind operatorul cast şi extragem cifrele.


float x,s=0;int c,sc=0;printf("x="); scanf("%f",&x);while(x==ceil(x)) //x nu are zecimale,este întreg{

s+=x;printf("x="); scanf("%f",&x);

}printf("suma numerelor citite este %d\n",(int)s);int s1=(int)s; //convertim suma la intwhile(s1){

c=s1%10; s1/=10; sc+=c; //suma cifrelor}printf("catul=%d\t restul=%d\n", (int)s/sc,(int)s%sc);getch();

}

30. Se citesc numere naturale până la introducerea valorii 17. Să se afişeze toate tripletele de numere citite consecutiv, în care al treilea număr este restul împărţirii primului la al doilea.

Observaţii:La fiecare pas avem nevoie de trei valori: valoarea curentă şi precedentele două valori citite. Pentru aceasta vom folosi trei variabile a,b,c. Primele două valori din şir le citim în afara ciclului while în variabilele a şi b. Dacă valorile citite sunt diferite de 17, citim în c valoarea curentă, verificăm proprietatea cerută, apoi transferăm în a valoarea lui b, în b valoarea lui c, iar în c citim următoarea valoare din şir.


int a,b,c;printf("a="); scanf("%d",&a);printf("b="); scanf("%d",&b);while(a!=17 && b!=17){

printf("c="); scanf("%d",&c);if(c==17) break;if(c==a%b) printf("%d %d %d\n",a,b,c);a=b; b=c;

}getch();

}

31. Să se determine cel mai mic număr de cinci cifre care începe şi se termină cu aceeaşi cifră nenulă şi pentru care restul împărţirii la un număr p este un număr r, numerele p şi r naturale nenule date.

Observaţii:Conform teoremei împărţirii cu rest, trebuie să determinăm cel mai mic număr de cinci cifre de forma x=nr*p+r, unde cel mai mic cât posibil este nr=[10000/p]+1. Vom genera pe rând numerele

36


de această formă şi vom verifica dacă au prima şi ultima cifră egală. Primul număr cu acestă proprietate este şi cel mai mic. Dacă numărul curent nu are proprietatea cerută, următorul număr verificat este x=(nr+1)*p+r.


int p,r,c1,c2,x,z,nr;printf("p,r="); scanf("%d %d",&p,&r);nr=10000/p+1;while(1){

x=nr*p+r; z=x; c1=z%10; z/=10;while(z){

c2=z%10; z/=10;}if(c1==c2){

printf("numarul cautat este %d\n",x);break;

}nr++;

}getch();

}

32. Să se calculeze cifra de control a unui număr întreg. Cifra de control a unui număr întreg se obţine prin efectuarea sumei cifrelor sale, apoi suma cifrelor acestei sume etc., până când se obţine o sumă formată dintr-o singură cifră, numită cifră de control.#include<stdio.h>#include<conio.h>void main(){

unsigned long int n;int s,c;printf("n="); scanf("%d",&n);do{

s=0; //suma cifrelor numărului curentwhile(n){

c=n%10; n/=10; s+=c;}n=s; //noul număr egal cu suma precedentă

}while(n>10); //până obţinem un număr de o singură cifră

printf("cifra de control este %d\n",n);getch();

}

33. Să se determine câte dintre numerele formate din n cifre, n dat, au cifra de control k, k dat.Observaţii:Toate cifrele de control pentru numere succesive parcurg circular mulţimea {1,2,..,9}. Numerele de n cifre sunt cele aflate între 10n-1 şi 10n-1. Cifra de control a numărului 10n-1 este 1, a lui 10n-1 este 9 şi există 10n-10n-1=10n-1*9 astfel de numere. Dintre acestea 10 n-1*9/10 vor avea cifra de control egală cu k. Deci răspunsul este 10n-2*9, adica se tipăreşte un 9 urmat de n-2 cifre de 0. Cazul n=1 se analizează separat.


int n,i;printf("n="); scanf("%d",&n);

37


if(n==1) printf("1\n");else{

printf("9");for(i=1;i<=n-2;i++) printf("0");printf("\n");

}getch();

}

34. Să se afişeze primele n numere prime (n<999) care citite invers sunt tot numere prime.#include<stdio.h>#include<conio.h>void main(){

int n,x,i,y,z,nr,ok,c;printf("n="); scanf("%d",&n);//primele 4 numere prime le putem afişa directprintf("2\t3\t5\t7\t");nr=4; x=11;

//căutăm numerele prime >=11while(nr<n){

ok=1; //verificăm dacă x este număr primfor(i=2;i<=x/2;i++)

if(!(x%i)) {ok=0; break;}if(ok) //x este număr prim{

y=x; z=0; //formăm în z numărul cu cifrele în //ordine inversă

while(y){ c=y%10; y/=10; z=z*10+c; }//verificăm dacă z este primfor(i=2;i<=z/2;i++)

if(!(z%i)){ ok=0; break;}

if(ok) //şi numărul invers este prim{

printf("%d\t",x); //îl afişămnr++; //îl numărăm

}}x+=2; //trecem la următorul număr impar şi

//reluşm verificarea}getch();

}

35. Se citeşte un număr natural n care reprezintă numărul de valori naturale ce vor fi citite ulterior. Să se determine cu câte zerouri se sfârşeşte produsul celor n numere, fără a efectua produsul respectiv.

Observaţii:Ştim că un număr se încheie cu 0 dacă este multiplu de 10, adică de 2 şi de 5 simultan. Este suficient să determinăm la ce putere apare 2, respectiv 5, în cele n numere şi să considerăm minimul dintre cele două valori. Acest minim va reprezenta numărul zerourilor cu care se încheie produsul celor n numere.


int n,x,nr2=0,nr5=0,i;

38


//nr2 este puterea lui 2, nr5 puterea lui 5printf("n="); scanf("%d",&n);for(i=1;i<=n;i++){

printf("x%d=",i); scanf("%d",&x);//determinăm puterea lui 2 în nr.ul curent xwhile(!(x%2)) { x/=2; nr2++; }//determinăm puterea lui 5 în nr.ul curent xwhile(!(x%5)){ x/=5; nr5++; }

}int min=nr2<nr5 ? nr2 : nr5;printf("produsul celor %d numere se termina cu %d

zerouri\n",n,min);getch();

}

36. Se citesc întâi două numere naturale n şi k şi apoi n numere reale. Să se verifice dacă, în ordinea citirii, cele n numere sunt ordonate crescător până la al k-lea număr citit şi apoi descrescător până la ultimul număr citit. Se va afişa un mesaj corespunzător.#include<stdio.h>#include<conio.h>void main(){

int n,k,i,x,y,ok=1;printf("n="); scanf("%d",&n);printf("k="); scanf("%d",&k);//citim primul număr din şir separat,în xprintf("x1="); scanf("%d",&x);//citim următoarele k-1 numerefor(i=2;i<=k;i++){

printf("x%d=",i); scanf("%d",&y);//numărul curent se citeşte în yif(y<x) ok=0; //nu sunt în ordine cresc.x=y; //păstrăm y în x pentru pasul următor

}//citim restul numerelorfor(i=k+1;i<=n;i++){

printf("x%d=",i); scanf("%d",&y);//numărul curent se citeşte în yif(y>x) ok=0; //nu sunt în ordine descresc.x=y; //păstrez y în x pentru pasul următor

}if(ok)

printf("numerele au proprietatea ceruta\n");else

printf("numerele nu au proprietatea ceruta\n");

getch();}

37. Să se scrie un program care să afişeze un meniu de forma:1.suma numerelor2.produsul numerelor3.diferenţa numerelor

şi apoi să permită citirea a câte două numere întregi şi prelucrarea acestora conform opţiunii introduse de utilizator, cât timp utilizatorul doreşte acest lucru.

Observaţii: Pentru prelucrarea opţiunilor din meniu utilizăm o instrucţiune switch(). În cazul

39


împărţirii trebuie să verificăm dacă împărţitorul nu este nul. Ieşirea din bucla de citire şi prelucrare se face cu un break atunci când introducem o opţiune de ieşire.


int a,b;char opt; //opţiunea utilizatoruluido{

printf("\n\t\tMeniu:\n");printf("1- Adunarea numerelor\n");printf("2- Inmultirea numerelor\n");printf("3- Impartirea numerelor\n");printf("4- Iesire\n");printf("\nIntroduceti optiunea: ");scanf("%d",&opt);if(opt==4) break; //oprirea programuluiprintf("\nIntroduceti valorile a,b=");scanf("%d %d",&a,&b);switch(opt){

case 1: printf("\n\tsuma=%d\n",a+b); break;

case 2: printf("\n\tprodusul=%d\n", a*b);

break;case 3: if(b)

printf("\n\tcatul=%.3f\n", (float)a/b);

else printf("\n\tImpartire la 0!\n");

break;}

}while(1);getch();

}

38. Să se citească un număr întreg şi să se scrie acesta fără zerouri (în cazul în care printre cifrele lui sunt şi zerouri).#include<stdio.h>#include<conio.h>void main(){

unsigned long n,inv=0;char cifra;printf("numarul n="); scanf("%lu",&n);//extragem cifrele lui n şi formăm numărul invers

//fără zerouriwhile(n){

cifra=n%10; n/=10; if(cifra) //cifră nenulă

inv=inv*10+cifra;}//extragem cifrele din inv şi refacem numărul nwhile(inv){

cifra=inv%10; inv/=10;n=n*10+cifra;

}printf("\nnumarul fara zerouri este %lu\n",n);

40


getch();}

39. Să se găsească numărul de elemente din şirul lui Fibonacci cuprinse într-un interval [a,b] dat.#include<stdio.h>#include<conio.h>void main(){

int a,b,x=0,y=1,z,nr;//nr=numarul termenilor din interval//x=primul termen,y=al doilea termen Fibonacciprintf("intervalul [a,b]=");scanf("%d %d",&a,&b);if(a<=x) nr=2; //termenii 0 si 1else

if(a<=y) nr=1; //termenul 1else nr=0;

z=x+y; //următorul termen Fibonacciwhile(z<=b){

if(z>=a) nr++; //termenul este în intervalx=y; y=z;z=x+y;

}printf("\n\tnumarul termenilor este %d\n",nr);getch();

}

40. Se citesc pe rând n numere întregi. Să se determine valoarea maximă din şir şi să se precizeze dacă este unică. În cazul în care nu este unică, să se determine numărul ei de apariţii.

Observaţii:Presupunem că prima valoare din şir este maximă, deci are o apariţie. Comparăm pe rând acest maxim cu următoarele valori citite. Dacă valoarea citită este mai mare, am găsit un alt maxim. Actualizăm valoarea maximă şi reiniţializăm numărul ei de apariţii cu 1. Dacă valoarea citită este egală cu cea maximă, incrementăm numărul ei de apariţii.


int n,x,max,nr; //nr=număr apariţii maximprintf("numarul valorilor, n=");scanf("%d",&n);printf("x1="); scanf("%d",&x);max=x; nr=1;for(int i=2;i<=n;i++){

printf("x%d=",i); scanf("%d",&x);if(max<x) //am găsit un nou maxim{

max=x; nr=1;}else

if(max==x) nr++;}printf("\nmaximul este %d si ",max);if(nr==1)

printf("este singular\n");else

printf("apare de %d ori\n",nr);getch();

}

41


41. Se citesc pe rând cifrele zecimale ale unui număr natural cu cel puţin 12 cifre . Să se determine lungimile platourilor care apar în număr. Prin platou se înţelege o succesiune de cifre egale. Spre exemplu, numărul 12333799025 conţine două platouri: 333 de lungime 3 şi 99 de lungime 2.

Observaţii:Prima problemă care se ridică este modul de citire a datelor de intrare. Deoarece numărul cifrelor este mare, valoarea nu poate fi stocată într-o variabilă de tip întreg. Vom trata cifrele numărului ca pe un şir de caractere şi le vom citi în mod bufferat cu funcţia getchar(). Acest mod de citire ne permite să afişăm rezultatele abia după ce am citit toate caracterele şi am apăsat Enter (bufferul de intrare se goleşte). Citim prima cifră din şir separat. Ea face parte dintr-un platou a cărui lungime k va fi cel puţin 1. Restul cifrelor le citim până la apăsarea tastei Enter (caracterul citit fiind ‘\n’). Fiecare cifră y citită o comparăm cu cifra precedentă, păstrată în x. Dacă sunt egale lungimea platoului curent creşte. Dacă sunt diferite, tocmai s-a încheiat un platou de lungime k pentru cifra x şi începe un nou platou cu lungimea iniţială 1 pentru cifra y.


char x,y,k;//k este lungimea unui platou//x este cifra citită la pasul anterior//y este cifra curentăprintf("\tIntroduceti numarul:\n");x=getchar(); //prima cifrăk=1;while(x!='\n'){

y=getchar(); //următoarea cifrăif(x==y)

k++; //lungimea platoului curent creşte

else //s-a încheiat platoul precedent{

if(k>1) //are cel puţin două elemente

printf("\tplatou de lungime %d pentru cifra %c\n",k,x);

k=1; //începe un nou platou de lungime 1

}x=y; //pentru pasul următor

}if(k>1) //pentru ultima cifră

printf("\tplatou de lungime %d pentru cifra %c\n",k,x);

getch();}

42. Se citesc pe rând n numere întregi. Să se determine numărul maxim de elemente consecutive aflate în ordine strict crescătoare.

Observaţii:Algoritmul este asemănător cu cel de la problema anterioară. Primul element se citeşte separat. El face parte dintr-o secvenţă crescătoare cu lungimea k cel puţin 1, care momentan este şi lungime maximă. La fiecare pas se compară valoarea curentă citită y cu valoarea anterioară x. Dacă y>x atunci lungimea secvenţei curente creşte. În caz contrar tocmai s-a încheiat o secvenţă strict crescătoare (ultima ei valoare este x) de lungime k şi începe o nouă secvenţă (prima ei valoare este y) de lungime 1. Pentru secvenţa anterioară verificăm dacă are lungimea k mai mare decât maximul curent. În caz afirmativ actualizăm acest maxim. Pentru ultma valoare citită trebuie făcută separat aceeaşi verificare.


42


void main(){

int n,x,y,max,k;//x este valoarea citită la pasul anterior//y este valoarea citită la pasul curent

//k este lungimea secvenţei strict crescătoare curentă//max este lungimea maximă a unei astfel de secvenţe

printf("numarul valorilor, n=");scanf("%d",&n);printf("x1="); scanf("%d",&x);k=max=1; //prima secvenţă conţine primul elementfor(int i=2;i<=n;i++){

printf("x%d=",i);scanf("%d",&y);if(y>x)

k++; //creşte lungimea secvenţei curente

else //s-a încheiat secvenţa anterioară{

if(k>max) //o secvenţă mai lungămax=k;

k=1; //noua secvenţă conţine elem. y}x=y; //pentru pasul următor

}if(k>max) //pentru ultima valoare citită

printf("\n\tlungimea maxima este %d\n",k);else

printf("\n\tlungimea maxima este %d\n",max);getch();

}

43. Se citeşte de la tastatură un text, caracter cu caracter, până la apăsarea tastei Enter. Textul este format din cuvinte separate prin unul sau mai multe spaţii. Să se numere cuvintele din text.

Observaţii:Considerăm un text corect sintactic, adică începe şi se termină cu un cuvânt. Citirea textului se face caracter cu caracter, în mod bufferat, cu funcţia getchar(). Când se citeşte ‘\n’ (s-a apăsat tasta Enter), citirea se încheie şi se afişează rezultatul. Ştiind că spaţiul separă două cuvinte, când citim un spaţiu numărăm cuvântul care tocmai s-a încheiat. Deoarece pot fi mai multe spaţii între cuvinte, le citim fără să le numărăm până când ajungem fie la prima literă din următorul cuvânt, fie s-a apăsat Enter. Deoarece ultimul cuvânt se încheie cu Enter şi nu se mai numără, numărul real al cuvintelor este mai mare cu 1.


char c,nr=0;printf("\tIntroduceti textul incheiat cu

Enter:\n");while(1){

c=getchar();if(c=='\n') break;if(c==' ') nr++;while(c==' ') c=getchar();

}printf("\n\ttextul contine %d cuvinte\n",nr+1);getch();

}

43


44. Se citesc mai multe caractere până la întâlnirea caracterului ')'. Verificaţi dacă expresia formată din înlănţuirea acestor caractere reprezintă un număr zecimal periodic. În caz afirmativ să se determine două numere întregi prime între ele al căror raport este chiar numărul zecimal dat.

Observaţii:Se reţin prin citirea caracter cu caracter trei numere importante: numărul reprezentând partea întreagă (nr), numărul reprezentând partea zecimală neperiodică (zec) şi numărul reprezentând partea zecimală periodică (per). Formula matematică de transformare a unui număr zecimal în fracţie este:

unde cifra 9 apare de l ori şi cifra 0 de n ori.#include<stdio.h>#include<stdlib.h>#include<conio.h>void main(){

unsigned char ok,c,n,l,j;unsigned long nr,zec,per,f,nmr,nmt,deimp,imp,rest;printf("\n\tIntroduceti un numar zecimal:\n");nr=zec=per=n=l=0;ok=1;//citim partea întreagă a număruluido{

c=getchar();if(c>='0' && c<='9')

nr=nr*10+c-'0';else

if(c=='.') ; //instrucţiune vidă

else ok=0;

}while(c!='.' && c!=')');if(!ok){

printf("\nexpresia nu este corecta!\n");exit(0);

}//citim partea zecimală neperiodicădo{

c=getchar();if(c>='0' && c<='9'){

zec=zec*10+c-'0'; n++; //numărăm cifrele

}else

if(c=='(') ; //instrucţiune vidă

else ok=0;

}while(c!='(' && c!=')');if(!ok){


}//citim partea zecimală periodicădo{

c=getchar();if(c>='0' && c<='9'){

44


per=per*10+c-'0'; l++;//numaram cifrele

}else

if(c==')') ; //instrucţiune vidă

else ok=0;

}while(c!=')');if(!ok){


}printf("\n\texpresia este corecta\n");//nmt=numitorul nmr=numărătorulf=1;for(j=1;j<=l;j++) f*=10;nmt=zec*f+per;nmt-=zec; nmr=0;for(j=1;j<=l;j++) nmr=nmr*10+9;for(j=1;j<=n;j++)nmr*=10;nmt+=nr*nmr; //introducerea întregilor în fracţiedeimp=nmt; imp=nmr; //alg. Euclidrest=deimp%imp;while(rest){

deimp=imp; imp=rest;rest=deimp%imp;

}nmt/=imp; nmr/=imp; //simplificareaprintf("%lu si %lu\n",nmt,nmr);getch();

}

45. Se introduce de la tastatură un număr natural. Să se determine numărul minim şi numărul maxim care se obţin prin eliminarea unei singure cifre din numărul dat.

Observaţii:Pentru minim eliminăm prima cifră care este urmată de o cifră cu valoare mai mică (de la stânga spre dreapta), iar pentru maxim pe cea urmată de o cifră mai mare (de la stânga la dreapta). În cazul în care nu există o astfel de cifră, se elimină ultima cifră. Perechile de cifre se extrag şi se studiază de la dreapta la stânga folosind cifra_curenta,cifra_prec.


unsigned long n,nn,f;unsigned char nr_cif,pmin,pmax, i,cifra_curenta,cifra_prec;do{ printf("introduceti un numar format din mai multe cifre: ");

scanf("%lu",&n); }while(n<=9);

nr_cif=0; nn=n; //calculează numărul de cifre ale lui ndo{ nr_cif++; nn/=10;}while(nn);pmin=pmax=i=0; //rangul ultimei cifrenn=n;cifra_curenta=n%10;

45


cifra_prec=n%100/10;while(nn>9){ if(cifra_curenta<cifra_prec) pmin=i+1; else pmax=i+1; nn/=10; cifra_curenta=cifra_prec; cifra_prec=nn%100/10; i++;}

f=1; for(i=1;i<=pmax;i++) f*=10;printf("\nnumarul maxim este

%lu\n",n/(f*10)*f+n%f); f=1; for(i=1;i<=pmin;i++) f*=10; printf("\nnumarul minim este %lu\n",n/(f*10)*f+n%f);

getch();}

46. Se consideră două numere întregi. Să se stabilească dacă acestea sunt termeni consecutivi în şirul Fibonacci.

Observaţii:Plecăm de la numerele date şi calculăm elementele şirului înapoi după formula termen=diferenţa-termenilor-imediat-următori. Dacă obţinem doi termeni succesiviegali cu 1, răspunsul este DA, altfel este NU.


long a,b,c;printf("numarele a,b: ");

scanf("%ld %ld",&a,&b); if(a>b)

{ c=a; a=b; b=c; } while(b>1) { c=b-a; b=a; a=c; }

if(a==1 && b==1) printf("\nDA\n"); else printf("\nNU\n");

getch();}

47. Se consideră un număr n scris în baza 10. Să se determine diferenţa dintre suma pătratelor cifrelor ce constituie partea sa întreagă şi suma pătratelor cifrelor zecimale.

Observa ţii: Metoda de citire şi validare a corectitudinii numărului introdus este asemănătoare cu cea de la problema 44.


unsigned s1=0,s2=0; char c; printf("\n\tIntroduceti un numar zecimal:\n");

46


c=getchar(); while(c!='.') //citim partea întreagă

{ if(c>='0' && c<='9') s1+=(c-'0')*(c-'0'); else { printf("\nnumar eronat\n"); exit(0); } c=getchar(); } c=getchar(); while(c!='\n') //citim partea zecimală { if(c>='0' && c<='9') s2+=(c-'0')*(c-'0'); else { printf("\nnumar eronat\n"); exit(0); } c=getchar(); } printf("\ndiferenta dintre %u si %u este

%d\n",s1,s2,s1-s2);getch();

}

48. Se citesc pe rând de la tastatură mai multe caractere ce pot fi numai cifre nenule,unul din operatorii '+','-','*','/' sau semnul '=', citirea făcându-se până la întâlnirea semnului '='. Se consideră că şirul de caractere reprezintă o expresie corectă din punct de vedere matematic şi că operaţiile se fac în ordinea în care sunt scrise. Să se afişeze valoarea acestei expresii.#include<stdio.h>#include<conio.h>void main(){

double val; char c1,c2; printf("\tIntroduceti expresia:\n"); //primul caracter trebuie sa fie o cifră

c1=getchar(); val=c1-'0'; //valoarea expresiei

while(1) { c1=getchar(); if(c1=='=') break; c2=getchar(); switch(c1){ case '+': val+=c2-'0'; break; case '-': val-=c2-'0'; break; case '*': val*=c2-'0'; break; case '/': val/=c2-'0'; break; } } printf("\nvaloarea expresiei este %g\n",val);

getch();}

B. Probleme propuse

47


1. Să se calculeze:a) S=1+3+5+…+nr, unde nr este un număr impar mai mic sau cel mult egal cu n, n

număr natural nenul datb) P=1*3*5*….*nr, unde nr este un număr impar mai mic sau cel mult egal cu n, n

număr natural nenul datc) S=1+1/2+1/3+...+1/n, n număr natural nenul datd) S=1+1*2+1*2*3+….+1*2*..*n, n număr natural nenul date) S=1+22+32+....+n2, n număr natural nenul datf) S=1+1/22+1/32+...+1/n2, n număr natural nenul datg) S=1+1/(1*2)+1/(1*2*3)+....+1/(1*2*...*n), n număr natural nenul dath) R=(1*2*...*n)/(1+2+...+n), n număr natural nenul dati) P=2*4*6*.....*nr, unde nr este un număr par mai mic sau cel mult egal cu n, n număr

natural nenul dat2. Se dau două numere naturale a şi n. Să se calculeze an prin înmulţiri repetate.3. Se citesc pe rând de la tastatură numere întregi nenule într-o variabilă x, până la introducerea

valorii 0. Să se calculeze suma numerelor pozitive introduse şi produsul celor negative.4. Se consideră şirul 1,4,7,10,13,....Să se calculeze suma primilor n termeni, n număr natural

nenul dat.5. Se citesc pe rând n numere dintr-un interval (a,b) dat. Să se determine media aritmetică a

valorilor strict pozitive introduse. Programul va valida încadrarea valorilor în intervalul deschis (a,b) dat.

6. Se citesc pe rând n numere întregi şi apoi o valoare întreagă a. Să se determine numărul de apariţii ale valorii a printre numerele citite.

7. Dându-se un număr natural n şi o valoare p, să se determine cifra aflată în număr pe poziţia p, de la dreapta spre stânga. Dacă numărul conţine mai puţin de p cifre se va afişa un mesaj corespunzător.

8. Să se genereze toate numerele de patru cifre de forma 3a2b care se divid cu numărul 9.9. Se citeşte o succesiune de numere întregi până la introducerea valorii 0. Să se calculeze

media aritmetică a numerelor pozitive citite şi numărul numerelor negative.10. Se citesc pe rând n numere întregi. Să se determine câte numere pare şi, respectiv, câte

numere impare au fost citite.11. Se dă de la tastatură un număr natural n mai mic sau egal cu 5000. Se cere să se afişeze

numerele naturale mai mici sau egale cu n care au exact trei divizori proprii.12. Se citesc pe rând numere întregi până la introducerea valorii –1. Să se calculeze media

aritmetică a valorilor nenule citite.13. Se citesc pe rând n numere naturale nenule. Să se afişeze şi să se numere acele numere

pentru care suma cifrelor este divizibilă cu 5.14. Se citesc pe rând n numere naturale mai mari ca 1. Să se determine c.m.m.d.c. al celor n

numere.15. Se citesc numere naturale până la introducerea valorii 0. Să se afişeze toate tripletele de

numere citite consecutiv, în care al treilea număr este media aritmetică dintre primul şi al doilea.

16. Se citesc numere naturale până la introducerea valorii 0. Să se afişeze toate perechile de numere citite consecutiv, cu proprietatea că al doilea număr este egal cu suma cifrelor primului număr.

17. Să se afişeze toate perechile de numere naturale citite consecutiv, cu proprietatea că al doilea număr reprezintă restul împărţirii primului număr la suma cifrelor sale. Introducerea numerelor se încheie cu 0.

18. Se citesc numere naturale până la introducerea valorii 13. Să se afişeze toate perechile de numere citite consecutiv, cu proprietatea că al doilea număr reprezintă numărul de apariţii ale cifrei 3 în pătratul primului număr.

19. Să se afişeze toate tripletele de numere citite consecutiv cu proprietatea că al treilea număr este suma dintre primul şi al doilea. Introducerea datelor se încheie la introducerea a două numere consecutive egale.

20. Se citesc numere reale pozitive până la introducerea valorii 0. Să se afişeze tripletele de numere citite consecutiv cu proprietatea că ele pot reprezenta laturile unui triunghi: (a) isoscel, (b) dreptunghic.

21. Să se afişeze toate numerele de forma a2+b3, cu 1<=a<=5 şi 1<=b<=5.22. Să se afişeze toate numerele mai mici decât n (număr natural nenul dat), care au suma

cifrelor divizibilă cu 5.23. Fiind dat un număr natural nenul n şi un număr prim p, să se stabilească la ce putere apare

factorul prim p în descompunerea numărului n dat.

48


24. Se dă ecuaţia de gradul al doilea ax2+bx+c=0 prin coeficienţii reali a,b,c. Să se calculeze sumele Sn=x1

n+x2n pentru n natural nenul dat, unde x1 şi x2 sunt rădăcinile ecuaţiei.

25. Se citeşte un număr natural cu maxim 9 cifre. Să se determine dacă este o putere a lui 2.26. Se citesc numerele naturale nenule n şi k şi apoi n numere naturale. Să se afişeze acele

numere dintre cele n citite care au exact k divizori proprii.27. Se citesc pe rând n numere reale. Să se calculeze şi să se afişeze raportul dintre suma

numerelor de rang impar şi suma numerelor de rang par după ordinea de citire.28. Se citeşte un număr natural nenul n. Să se afişeze numerele perfecte mai mici sau egale cu

n. Un număr perfect a fost definit de Pitagora ca fiind un număr egal cu suma divizorilor proprii plus 1. Exemplu: 6=1+2+3.

29. Cunoscând succesiunea 1,2,2,3,3,3,4,4,4,4,5,...să se precizeze valoarea elementului aflat pe poziţia k dată, fără a citi sau construi efectiv succesiunea.

30. Să se verifice dacă un număr natural nenul dat este cub perfect fără a folosi funcţii matematice de aproximare.

31. Pentru un număr natural nenul n dat, să se determine p natural cu proprietatea 2p<=n.32. Să se determine aria unui triunghi ale cărui vârfuri au coordonatele carteziene numere întregi

citite de la tastatură.33. Să se determine toate triunghiurile diferite cu laturile numere naturale şi perimetrul p dat.34. Se citeşte un număr natural n. Să se calculeze produsul primelor n numere naturale dacă

acesta încape în reprezentarea shortint, iar dacă nu, să se afişeze până la ce valoare s-a făcut calculul.

35. Să se scrie un program care rezolvă câte o ecuaţie de gradul doi de forma ax2+bx+c=0, dată prin coeficienţii reali a,b,c până când programatorul nu mai doreşte acest lucru.

36. Se dă de la tastatură un număr natural nenul n<=1000000. Să se afişeze numărul de apariţii ale cifrei 3 în numărul dat.

37. Se citesc de la tastatură numere naturale până la întâlnirea valorii 0. Să se afişeze perechile de numere citite consecutiv cu proprietatea că al doilea număr este egal cu pătratul primului.

38. Se dă un dreptunghi prin coordonatele (x1,y1), (x2,y2) ale vârfurilor stânga-sus, respectiv dreapta-jos. Laturile dreptunghiului sunt paralele cu axele de coordonate. Să se afişeze perechile de numere întregi (x,y) care reprezintă coordonatele punctelor din interiorul dreptunghiului.

39. Se consideră dreapta ax+by+c=0 dată prin coeficienţii săi întregi a,b,c şi o mulţime de n perechi de numere întregi (x,y) ce reprezintă coordonatele carteziene a n puncte în plan. Să se determine câte dintre aceste puncte aparţin dreptei date.

40. Să se verifice dacă trei puncte A,B,C ale căror coordonate numere întregi se citesc de la tastatură sunt sau nu colineare.

41. Să se calculeze lungimilor laturilor unui dreptunghi având laturile paralele cu axele de coordonate şi diagonala determinată de punctele M(a,b), N(c,d) cu a,b,c,d numere naturale date.

42. Se dau coordonatele carteziene x1,y1 şi x2,y2 pentru două puncte A şi B din plan. Să se determine lungimea segmentului format pe dreapta AB de punctele de intersecţie cu fiecare din axele de coordonate. Programul trebuie să prevadă şi să soluţioneze şi cazurile limită.

43. Să se determine intersecţia a două intervale [a,b] şi [c,d] date prin numerele reale a,b,c,d şi să se afişeze numerele întregi din intervalul de intersecţie, dacă acesta este nevid.

44. Să se afişeze numerele prime mai mici decât 100 făcând un număr cât mai mic de verificări.45. Se citesc numere naturale până la întâlnirea valorii 0. Să se afişeze perechile de numere citite

consecutiv cu proprietatea că suma celor două numere este multiplu de 7.46. Să se determine cel mai mare divizor propriu al unui număr natural n dat făcând un număr

minim de verficări.47. Să se determine într-un mod eficient cel mai mare număr prim mai mic decât o limită m dată.48. Se citesc de la tastatură diferite altitudini ale unui traseu turistic, numere reale strict pozitive.

Şirul valorilor se încheie la citirea valorii 0. Să se afişeze altitudinea minimă, maximă şi numărul altitudinilor citite.

49. Se dau două numere naturale având acelaşi număr de cifre (maxim 9). Să se determine câte cifre trebuie modificate pentru a transforma un număr în celălalt.

50. Se dau cifrele a două numere naturale x şi y, în ordinea crescătoare a rangului şi n, numărul de cifre ale lui x, respectiv y. Cifrele se citesc în ordine de la tastatură, câte o cifră din fiecare număr. Să se calculeze suma celor două numere şi să se afişeze rezultatul ca număr zecimal.

51. Se dă numărul natural nenul n. Să se determine cel mai mic număr par, obţinut din numărul dat prin eliminarea uneia din cifrele sale. Exemplu: din 576, eliminăm 7 şi obţinem 56.

52. Să se determine toate palindroamele de n cifre care au suma cifrelor egală cu m, m şi n numere naturale nenule date.

49


53. Se ştie că un număr natural n este deosebit dacă există un număr natural m astfel încât n=m+S(m), unde S(m) este suma cifrelor lui m. Exemplu: pentru n=15, există m=12 astfel încât 15=12+3. Să se determine toate numerele deosebite dintr-un interval [a,b] dat.

54. Scrieţi un program eficient care să afişeze toate pătratele perfecte mai mici sau egale cu n, n<=109, număr natural nenul dat.

55. Se citesc de la tastatură n numere reale (n<=100000). Să se stabilească dacă toate numerele citite se află sau nu în afara intervalului închis [a,b] dat.

56. Scrieţi un program eficient care să stabilească de câte ori apare o cifră nenulă c în scrierea tuturor numerelor naturale mai mici sau egale cu un număr dat k. Cifra c şi valoarea k se citesc de la tastatură.

57. Se citesc n numere întregi. Să se afişeze numerele libere de puteri. Un număr întreg se numeşte liber de puteri dacă factorii primi din descompunerea sa nu apar la o putere mai mare ca 1.

58. Să se determine la ce putere apare un număr k în descompunerea în factori primi a numărului natural nenul n, k şi n date.

59. Să se găsească două numere naturale nenule a şi b, astfel încât cmmdc(a,b)=m şi cmmmc(a,b)=n, unde m şi n sunt numere naturale date.

60. Se dă un număr par mai mare decât 4. Să se găsească toate modurile de a scrie acest număr ca sumă de două numere impare prime (conjectura lui Goldbach).

61. Se citesc pe rând n valori întregi nenule. Să se determine cea mai mare valoare strict negativă şi cea mai mică valoare strict pozitivă, precizându-se dacă sunt sau nu unice.

62. Se citesc pe rând n numere întregi. Să se determine lungimea platoului maxim. Prin platou se înţelege un şir de valori egale citite consecutiv.

63. Se citesc pe rând n numere reale. Să se determine numărul maxim de valori nule citite consecutiv.

64. Se citesc numere întregi până la introducerea valorii 0. Să se afişeze media armonică a oricăror trei valori strict pozitive citite consecutiv.

65. Se citesc de la tastatură trei numere naturale f,a şi b (a<b), fiecare număr având cel mult trei cifre. Să se afişeze o „tablă” cu toate înmulţirile de doi factori naturali dintre care unul este obligatoriu f şi care dau ca rezultate numai numere cuprinse între a şi b inclusiv. Înmulţirile vor fi afişate câte una pe linie, în ordinea crescătoare a rezultatelor. De exemplu, pentru f=5, a=8 şi b=25 se va afişa „tabla înmulţirilor cu 5” astfel:

2*5=103*5=154*5=205*5=25

66. Se citesc de la tastatură două numere naturale a şi b, fiecare număr având cel mult trei cifre. Să se afişeze pe ecran, câte unul pe linie, toate numerele naturale din intervalul închis determinat de a şi b care au suma cifrelor 15. Înţelegem prin interval închis determinat de valorile a şi b intervalul închis [a,b] dacă a<=b sau intervalul închis [b,a] dacă b<=a.

50


Cap.4 Tablouri

4.1 Tablouri unidimensionale (vectori)


1. Fiind dat un şir de n numere reale să se determine valoarea maximă.Observaţii:Se foloseşte algoritmul cunoscut: se iniţializează maximul cu prima valoare din şir, apoi se compară pe rând cu celelalte valori şi se actualizează (vezi metoda 6.3.2).

#include<stdio.h>#include<conio.h>#define N 50void main(){

int n,i;float a[N],max;printf("numarul de elemente,n=");do{

scanf("%d",&n);}while(n<1 || n>N);printf("\tIntroduceti elementele vectorului:\n");for(i=1;i<=n;i++){

printf("a[%d]=",i);scanf("%f",&a[i]);

}printf("\n\n\tVectorul introdus este:\n");for(i=1;i<=n;i++)

printf("%.3f ",a[i]);printf("\n\n");max=a[1];for(i=2;i<=n;i++)

if(max<a[i]) max=a[i];printf("valoarea maxima este %.3f\n",max);getch();

}

2. Fiind dat un şir de n numere întregi să se determine primul element divizibil cu un număr natural nenul k dat şi poziţia în care apare în şir.

Observaţii:Se foloseşte metoda descrisă la 6.3.3 (determinarea primului element cu o anumită proprietate), căutarea făcându-se de la stânga spre dreapta, fie până găsim primul element cu proprietatea cerută, fie epuizăm elementele vectorului.


int n,i,a[N],k,poz=0;printf("numarul de elemente,n=");do{


printf("a[%d]=",i);scanf("%d",&a[i]);

}

51


printf("\n\n\tVectorul introdus este:\n\n");for(i=1;i<=n;i++)

printf("%d ",a[i]);printf("\n\n");printf("k="); scanf("%d",&k);//parcurgem vectorul de la stanga spre dreaptafor(i=1;i<=n;i++)

if(!(a[i]%k)){

poz=i; break; //a[i] este primul element divizil cu k

}if(poz)

printf("\nprimul element divizibil cu %d este %d si apare in pozitia %d\n",k,a[poz],poz);

elseprintf("\nnu exista nici-un element divizibil

cu %d\n",k);getch();

}

3. Fiind dat un şir de n numere naturale nenule să se determine ultimul număr prim din şir şi poziţia în care apare.

Observaţii:Se foloseşte metoda descrisă la 6.3.4 (determinarea ultimului element cu o anumită proprietate), căutarea făcându-se de la dreapta spre stânga până găsim primul element prim sau epuizăm elementele vectorului.

#include<stdio.h>#include<stdlib.h>#include<math.h>#include<conio.h>#define N 50void main(){

int n,i,a[N],k,poz=0,ok;printf("numarul de elemente,n=");do{



}printf("\n\n\tVectorul introdus este:\n\n");for(i=1;i<=n;i++)

printf("%d ",a[i]);printf("\n\n");//parcurgem şirul de la dreapta spre stângafor(i=n;i>=1;i--){

ok=1; //verificăm dacă i este număr prim

for(k=2;k<=sqrt(a[i])+1;k++)if(!(a[i]%k)) //a[i] nu este prim{

ok=0; break; //abandonăm verificarea şi trecem //la următorul număr

}if(ok) //a[i] este ultimul număr prim

52


{poz=i;break;

}}if(poz)

printf("\nultimul element prim este %d si apare in pozitia %d\n",a[poz],poz);

elseprintf("\nnu exista nici-un element prim\n");

getch();}

4. Dându-se un vector de n numere reale, să se scrie un program care elimină elementele nule din şir fără a utiliza memorie suplimentară.

Observaţii:Se foloseşte metoda descrisă la 6.3.5 (eliminarea tuturor elementelor cu o anumită proprietate), valorile nenule „îngrămădindu-le” la începutul vectorului.


int n,i,j=0;float a[N];printf("numarul de elemente,n=");do{




printf("%.3f ",a[i]);printf("\n\n");for(i=1;i<=n;i++)

if(a[i]) //element nenula[++j]=a[i];

//îl mutăm la începtul vectoruluin=j; //actualizăm numărul de elementeprintf("\tVectorul obtinut este:\n\n");for(i=1;i<=n;i++)

printf("%.3f ",a[i]);printf("\n\n");getch();

}

5. Fiind dat un şir de n numere întregi, să se elimine din şir primul element care are suma cifrelor divizibilă cu 3. Dacă nu există nici-un element cu proprietatea cerută, să se elimine din şir primul element.

Observaţii:Se combină algoritmul de determinare a primului element cu o proprietate dată cu algoritmul de eliminare a elementului dintr-o poziţie k dată (vezi 6.3.3 şi 6.3.6).


int n,i,a[N],x,s,k=1;

53


printf("numarul de elemente,n=");do{




printf("%d ",a[i]);printf("\n\n");//parcurgem vectorul de la stânga spre dreaptafor(i=1;i<=n;i++){

//calculăm suma cifrelor lui a[i]x=a[i]; //lucrăm cu copia lui a[i]s=0; //suma cifrelorwhile(x){

s+=x%10;x/=10;

}if(!(s%3))

//suma cifrelor este divizibilă cu 3{

k=i; break; //am găsit primul număr}

}if(k!=1)

printf("\nprimul numar cu suma cifrelor divizibila cu 3 este %d\n",a[k]);

elseprintf("\nnu exista numar cu suma cifrelor

divizibila cu 3\n");//eliminăm din şir elementul din poziţia kfor(i=k;i<=n-1;i++)

a[i]=a[i+1];n--; //corectăm lungimeaprintf("\n\tVectorul obtinut dupa eliminare

este:\n\n");for(i=1;i<=n;i++)

printf("%d ",a[i]);printf("\n"); getch();

}

6. Fiind dat un şir de n numere întregi, să se determine poziţia în care apare ultimul număr palindromic şi apoi să se insereze în şir, în respectiva poziţie, o valoare x citită de la tastatură. Dacă şirul nu conţine nici-un număr palindromic să se adauge valoarea x la sfârşitul şirului.

Observaţii:Se combină algoritmul de determinare a ultimului element cu o anumită proprietate (6.3.4) cu algoritmul de inserare a unei noi valori în poziţia k dată (6.3.7).


int n,i,a[N],x,inv,k;printf("numarul de elemente,n=");do{

54





printf("%d ",a[i]);printf("\n\n");//parcurgem vectorul de la dreapta spre stângak=n+1;for(i=n;i>=1;i--){

//verificăm dacă a[i] este palindromx=a[i]; //lucrăm cu copia lui a[i]inv=0; //nr.-ul cu cifrele în ordine inversăwhile(x){

inv=inv*10+x%10;x/=10;

}if(inv==a[i]) //este palindrom{

k=i; break;} //oprim căutarea

}if(k!=n+1)

printf("\nultimul numar palindromic este %d\n",a[k]);

elseprintf("\nsirul nu contine nici-un numar

palindromic\n");printf("\nvaloarea inserata,x="); scanf("%d",&x);//inserăm x în poziţia kfor(i=n+1;i>=k+1;i--)

a[i]=a[i-1];a[k]=x; n++; //inserăm x şi corectăm lungimeaprintf("\n\tVectorul obtinut dupa inserare

este:\n\n");for(i=1;i<=n;i++)


}

7. Fiind dat un şir de n numere reale, să se permute circular numerele cu x poziţii spre dreapta, apoi cu y poziţii spre stânga, unde x şi y sunt numere naturale nenule, mai mici decât n şi diferite între ele citite de la tastatură. Se va afişa şirul obţinut după fiecare operaţie.

Observaţii:Se folosesc algoritmii descrişi în secţiunile 6.3.8 şi 6.3.9, repetaţi de y, respectiv de x ori.


int n,i,x,y,k;float a[N],aux;printf("numarul de elemente,n=");do{

scanf("%d",&n);

55


}while(n<1 || n>N);printf("\tIntroduceti elementele vectorului:\n");for(i=1;i<=n;i++){



printf("%.3f ",a[i]);printf("\n\n");printf("x,y=");do{

scanf("%d %d",&x,&y);}while(x<1 || x>=n || y<1 || y>=n || x==y);//permutăm întâi spre dreapta circular cu x poziţiifor(k=1;k<=x;k++){

aux=a[n];for(i=n;i>=2;i--)

a[i]=a[i-1];a[1]=aux;

}printf("\n\tVectorul obtinut dupa %d permutari

circulare spre dreapta:\n\n",x);for(i=1;i<=n;i++)

printf("%.3f ",a[i]);printf("\n");//permutăm spre stânga circular cu y poziţiifor(k=1;k<=y;k++){

aux=a[1];for(i=1;i<=n-1;i++)

a[i]=a[i+1];a[n]=aux;

}printf("\n\tVectorul obtinut dupa %d permutari

circulare spre stanga:\n\n",y);for(i=1;i<=n;i++)

printf("%.3f ",a[i]);printf("\n"); getch();

}

8. Fiind dat un şir de n valori reale, să se ordoneze crescător folosind metoda bubblesort.Observaţii:Se foloseşte algoritmul descris în secţiunea 6.3.10 A.


int n,i,k,ok;float a[N],aux;printf("numarul de elemente,n=");do{



}

56


printf("\n\n\tVectorul introdus este:\n");for(i=1;i<=n;i++)

printf("%.3f ",a[i]);printf("\n\n");k=n;do{

ok=0;for(i=1;i<k;i++)

if(a[i]>a[i+1]){

aux=a[i]; a[i]=a[i+1]; a[i+1]=aux; ok=1;

}k--;

}while(ok);printf("\n\tVectorul ordonat crescator este:\n\n");for(i=1;i<=n;i++)


}

9. Fiind dat un şir de n valori reale, să se ordoneze descrescător folosind sortarea prin selecţie directă.

Observaţii:Se foloseşte algoritmul descris în secţiunea 6.3.10 B.


int n,i,j;float a[N],aux;printf("numarul de elemente,n=");do{




printf("%.3f ",a[i]);printf("\n\n");for(i=1;i<n;i++)

for(j=i+1;j<=n;j++)if(a[i]<a[j]){

aux=a[i]; a[i]=a[j]; a[j]=aux;

}printf("\n\tVectorul ordonat crescator este:\n\n");for(i=1;i<=n;i++)


}

10. Fiind dat un şir de n numere întregi distincte şi o valoare întreagă x, să se verifice dacă x apare în şir şi pe ce poziţie. Dacă şirul de valori nu este ordonat, să se ordoneze şi apoi să se folosească algoritmul de căutare binară.

57


Observaţii:Pentru căutarea binară se foloseşte algoritmul descris în secţiunea 6.3.11, iar dacă şirul nu este ordonat, se ordonează folosind metoda B (ordonarea prin selecţie directă).

#include<stdio.h>#include<stdlib.h>#include<conio.h>#define N 50void main(){

int n,i,j,a[N],x,p,q,mij,aux,ok=1;printf("numarul de elemente,n=");do{




printf("%d ",a[i]);printf("\n\n");printf("valoarea cautata,x=");scanf("%d",&x);//verificăm dacă vectorul este ordonat crescătorfor(i=1;i<n;i++)

if(a[i]>a[i+1]){

ok=0; break; //şirul nu este ordonat}

if(!ok) //ordonăm şirul crescător{

printf("\n\nsirul initial nu a fost ordonat!\n");

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

if(a[i]>a[j]){

aux=a[i];a[i]=a[j];a[j]=aux;

}printf("\n\tVectorul dupa ordonare:\n\n");for(i=1;i<=n;i++)

printf("%d ",a[i]);printf("\n\n");

}//aplicăm algoritmul de căutare binarăp=1; q=n;while(p<=q){

mij=(p+q)/2;if(a[mij]==x){

printf("\nvaloarea %d apare in sir in pozitia %d\n",x,mij);

exit(0);}else

if(x<a[mij])q=mij-1;

58


elsep=mij+1;

}printf("\nvaloarea %d nu apare in sir\n",x);getch();

}

11. Fiind date două şiruri de numere întregi cu m, respectiv n elemente, să se interclaseze cele două şiruri folosind santinele. Dacă cele două şiruri nu sunt ordonate, se vor ordona folosind sortarea prin selecţie directă.

Observaţii:Pentru interclasare se foloseşte algoritmul de interclasare cu santinele prezentat în secţiunea 6.3.12.


int a[N],b[N],c[N],m,n,i,j,k,ok,aux;printf("cate elemente are primul vector? ");do{

scanf("%d",&m);}while(m<1 || m>N);printf("\n\tIntroduceti elementele primului

vector:\n\n");for(i=1;i<=m;i++){


}printf("\ncate elemente are al doilea vector? ");do{

scanf("%d",&n);}while(n<1 || n>N);printf("\n\tIntroduceti elementele pentru al doilea

vector:\n\n");for(i=1;i<=n;i++){

printf("b[%d]=",i);scanf("%d",&b[i]);

}//verificăm dacă vectorul a este ordonat crescătorok=1;for(i=1;i<m;i++)

if(a[i]>a[i+1]) //nu este ordonat crescător{

ok=0; break;}

if(!ok){

//ordonăm crescător vectorul aprintf("\nVectorul a nu este ordonat

crescator!\n");for(i=1;i<m;i++)

for(j=i+1;j<=m;j++)if(a[i]>a[j]){

aux=a[i]; a[i]=a[j]; a[j]=aux;

}printf("\n\tVectorul a dupa ordonare:\n\n");for(i=1;i<=m;i++)

59


printf("%d ",a[i]);printf("\n\n");

}//verificăm dacă vectorul b este ordonat crescătorok=1;for(i=1;i<n;i++)

if(b[i]>b[i+1]) //nu este ordonat crescător{

ok=0; break;}

if(!ok){

//ordonăm crescător vectorul bprintf("\nVectorul b nu este ordonat

crescator!\n");for(i=1;i<n;i++)

for(j=i+1;j<=n;j++)if(b[i]>b[j]){

aux=b[i]; b[i]=b[j]; b[j]=aux;

}printf("\n\tVectorul b dupa ordonare:\n\n");for(i=1;i<=n;i++)

printf("%d ",b[i]);printf("\n\n");

}//adăugăm santinelelea[m+1]=b[n]+1; b[n+1]=a[m]+1;i=1; j=1;//interclasăm vectoriifor(k=1;k<=m+n;k++)

if(a[i]<b[j])c[k]=a[i++];

elsec[k]=b[j++];

printf("\n\tVectorul obtinut dupa interclasare:\n\n");

for(i=1;i<=m+n;i++)printf("%d ",c[i]);

printf("\n"); getch();}

12. Să se scrie un program care citeşte un şir de n întregi şi afişează elementele pare situate pe poziţii impare ale şirului precum şi numărul acestora.#include<stdio.h>#include<conio.h>#define N 50void main(){

int n,i,a[N],k=0;printf("numarul de elemente,n=");do{




60


printf("%d ",a[i]);printf("\n\n");//parcurgem elementele situate pe poziţii imparefor(i=1;i<=n;i+=2)

if(!(a[i]%2)) //este park++; //numărăm elementele pare

printf("\nVectorul contine %d elemente pare situate pe pozitii impare\n",k);

getch();}

13. Să se scrie un program care citeşte n numere întregi şi afişează valorile distincte din şir fără a folosi memorie suplimentară.

Observaţii:Pentru a reţine în vector numai valorile distincte se foloseşte un algoritm asemănător cu cel descris în secţiunea 6.3.5. Valorile distincte se mută la începutul vectorului, pe poziţii succesive. Primul element îşi păstrează poziţia astfel încât verificările se fac începând cu al doilea element. Numărul curent al valorilor distincte mutate la începutul vectorului este k (iniţial are valoarea 1 pentru că a[1] îşi păstrează poziţia).


int n,i,a[N],k=1,j,ok; //k este numărul valorilor distincteprintf("numarul de elemente,n=");do{




printf("%d ",a[i]);printf("\n\n");for(i=2;i<=n;i++){

ok=1; //presupunem că a[i] este distinctfor(j=1;j<=k;j++)

if(a[i]==a[j]) //se repetă{

ok=0; break;}

if(ok) //este distincta[++k]=a[i];

//îl mutăm la începutul vectorului}printf("\n\tValorile distincte din sir sunt:\n\n");for(i=1;i<=k;i++)


}

14. Scrieţi un program care citeşte cele n elemente ale unui vector de numere reale şi determină minimul acestor elemente precum şi poziţia (poziţiile) în care acesta apare în vector.

Observaţii:

61


Pentru determinarea minimului s-a iniţializat valoarea variabilei corespunzătoare cu o valoare foarte mare (231-1) astfel încât orice valoare din vector să-l actualizeze corect. Pentru a determina toate poziţiile în care apare minimul se mai foloseşte un vector poz. Când găsim în vector un element egal cu minimul curent, indicele elementului respectiv se memorează în poz în următoarea poziţie liberă. Când se găseşte o valoare mai mică decât minimul curent, se şterg toate poziţiile memorate în poz (indicele lui curent devine 0) şi se memorează poziţia noului minim.


int poz[N],n,i,j=0;float a[N],min=1<<31-1;printf("numarul de elemente,n=");do{




printf("%.3f ",a[i]);printf("\n\n");for(i=1;i<=n;i++)

if(a[i]<min){

min=a[i]; j=0; //un nou minimpoz[++j]=i;

}else

if(min==a[i]) poz[++j]=i;

//o nouă apariţie a minimului curentprintf("\nminimul este %.3f si se gaseste in

pozitiile: ",min);for(i=1;i<=j;i++)

printf("%d ",poz[i]);printf("\n"); getch();

}

15. Fiind dat un şir de numere reale cu n elemente, să se afle numărul de ordine al primului şi, respectiv ultimului element nul întâlnit.

Observaţii:Pentru rezolvarea problemei se parcurge vectorul simultan din ambele capete folosind doi indici: prim iniţial egal cu 1 şi ultim iniţial egal cu n. Indicele prim creşte iar indicele ultim scade fie până găsim cele două (unul) elemente nule, fie până când prim devine mai mare decât ultim, semn că am inspectat fără succes toate elementele vectorului.


int n,i,prim,ultim;float a[N];printf("numarul de elemente,n=");do{

scanf("%d",&n);

62


}while(n<1 || n>N);printf("\tIntroduceti elementele vectorului:\n");for(i=1;i<=n;i++){



printf("%.3f ",a[i]);printf("\n\n");//parcurgem şirul simultan din ambele capeteprim=1; ultim=n;do{

if(a[prim]) prim++;if(a[ultim]) ultim--;if(prim>ultim) break;

}while(a[prim] || a[ultim]);if(prim>ultim)

printf("\nsirul nu contine nici un zero\n\n");

else{

printf("\nprimul 0 apare in pozitia %d\n\n",prim);

printf("\nultimul 0 apare in pozitia %d\n\n",ultim);

}getch();

}

16. Citiţi un şir de n valori întregi şi inversaţi ordinea elementelor din şir.Observaţii:Pentru rezolvarea problemei este suficient să interschimbăm elementele egal depărtate de mijlocul vectorului. Elementul din mijloc are indicele [n/2] iar perechea de elemente simetrice este a[i] , a[n-i+1].


int n,i,a[N],aux;printf("numarul de elemente,n=");do{




printf("%d ",a[i]);printf("\n\n");//inversăm ordinea elementelor egal depărtate de// mijlocul şiruluifor(i=1;i<=n/2;i++){

aux=a[i]; a[i]=a[n-i+1];a[n-i+1]=aux;

63


}printf("\n\n\tVectorul inversat este:\n\n");for(i=1;i<=n;i++)


}

17. Generaţi numerele prime din intervalul [2,n], unde n este un număr natural introdus de utilizator, după metoda numită „ciurul lui Eratostene”.

Observaţii:Metoda matematică constă în: se umple „ciurul” (vectorul) cu toate numerele de la 2 la n. Primul număr din şir (2) este prim. Se elimină din şir toţi multiplii de 2 transformând elementele respective în 0. Următorul număr nenul din şir (3) este prim. Se elimină din şir toţi multiplii de 3 s.a.m.d. În final, numerele nenule rămase sunt toate numere prime.


unsigned a[N],n,i,j;printf("numarul n=");do{

scanf("%d",&n);}while(n<=2 || n>N);for(i=2;i<=n;i++) a[i]=i;

//numerele din intervalul [2,n]for(i=2;i<=n/2;i++)

if(a[i]) //a[i] este număr prim//ştergem din vector toţi multiplii lui a[i]

for(j=2*i;j<=n;j+=i) a[j]=0; printf("\n\tNumerele prime din intervalul [2,%d]

sunt:\n\n",n);for(i=2;i<=n;i++)

if(a[i]) printf("%d ",a[i]);printf("\n"); getch();

}

18. Să se calculeze valoarea polinomului P(x) de grad n şi coeficienţi reali daţi, pentru o valoare x dată folosind „gruparea lui Horner”. Coeficienţii polinomului sunt memoraţi vectorial.

Observaţii:Prin această metodă coeficienţii polinomului sunt luaţi în considerare în ordinea descrescătoare a puterilor lui x. Metoda evită ridicarea la putere a argumentului x folosind formula de calcul iterativă: Pi(x)=Pi-1(x)*x+an-i


int n,i;double a[N],x,P=0;printf("gradul polinomului,n=");do{

scanf("%d",&n);}while(n<0 || n>N);printf("\n\tIntroduceti coeficientii in ordinea

desrescatoare a puterilor lui X:\n\n");for(i=n;i>=0;i--){

printf("a[%d]=",i);scanf("%lf",&a[i]);

}printf("\npunctul x=");

64


scanf("%lf",&x);printf("\n\tPolinomul dat este:\n\n");printf("P(x)=");for(i=n;i>=0;i--)

printf("%+g*x^%d ",a[i],i);printf("\n\n");for(i=n;i>=0;i--)

P=P*x+a[i];printf("P(%g)=%g\n\n",x,P); getch(();

}

19. Se dă un vector x cu n (1<=n<=100) componente numere naturale cu cel mult nouă cifre. Se cere să se afişeze numărul cel mai mare format cu prima cifră a fiecărei componente din x. Exemplu: pentru n=4 şi x=(2341, 789, 1998, 2000) se va afişa 7221.

Observaţii:Extragem prima cifră din fiecare număr şi o memorăm într-un vector. Sortăm acest vector descrescător şi obţinem cel mai mare număr.


int x[100],c[100],n,i,j,aux,cifra,y;printf("n="); scanf("%d",&n);for(i=1;i<=n;i++){

printf("x[%d]=",i); scanf("%d",&x[i]);}for(i=1;i<=n;i++){

y=x[i]; //folosim o copie a număruluiwhile(y){ cifra=y%10;

y/=10;}c[i]=cifra; //este prima cifră din număr

}//ordonăm crescător vectorul cfor(i=1;i<=n-1;i++)

for(j=i+1;j<=n;j++)if(c[i]<c[j]){

aux=c[i]; c[i]=c[j]; c[j]=aux;}

printf("\n Cel mai mare numar posibil este ");for(i=1;i<=n;i++) printf("%d",c[i]);printf("\n"); getch();

}

20. Se dau două mulţimi prin intermediul a doi vectori, x şi y, cu n (1<=n<=100) componente întregi. Se cere să se verifice dacă aceste mulţimi sunt proporţionale. În caz afirmativ se va afişa şi şirul de rapoarte egale.

Observaţii:Observând proprietăţile matematice ale numerelor care formează un şir de rapoarte egale, vom constata că dacă numitorii sunt în ordine crescătoare, atunci şi numărătorii sunt tot în ordine crescătoare. Deci ordonăm elementele celor două mulţimi şi formăm perechile corespunzătoare pentru a verifica proporţionalitatea directă.


int a[50],b[50],n,i,j,aux,dir=1;

65


float rap,t;printf("n="); scanf("%d",&n);printf("\t Prima multime:\n");for(i=1;i<=n;i++){

printf("a[%d]=",i); scanf("%d",&a[i]);}printf("\t A doua multime:\n");for(i=1;i<=n;i++){

printf("b[%d]=",i); scanf("%d",&b[i]);}//ordonăm crescător numărătoriifor(i=1;i<=n-1;i++)

for(j=i+1;j<=n;j++)if(a[i]>a[j]){

aux=a[i]; a[i]=a[j]; a[j]=aux;}

//ordonăm crescător numitoriifor(i=1;i<=n-1;i++)

for(j=i+1;j<=n;j++)if(b[i]>b[j]){

aux=b[i]; b[i]=b[j]; b[j]=aux;}

rap=(float)a[1]/b[1]; //valoarea raportuluifor(i=2;i<=n;i++){

t=(float)a[i]/b[i];//fiind vorba de valori reale reprezentate //intern prin aproximare,putem considera //două valori ca fiind egale dacă diferenţa//lor în modul este mai miîa decât 0.00001 //(de exemplu);în acest fel se evită erorile//ce pot apărea la evaluarea egalităţii //numerelor realeif(fabs(t-rap)>1e-5) { dir=0; break; }

}if(!dir)

printf("multimile nu sunt direct proportionale\n");

else{

printf("multimile sunt direct proportionale; sirul de rapoarte egale este:\n");

for(i=1;i<=n;i++)printf("%d/%d=",a[i],b[i]);

printf("%g\n",rap);}getch();

}

21. Se dau două numere naturale în baza 2 prin intermediul a doi vectori, x şi y, cu m, respectiv n componente binare (1<=n,m<=100). Fără a trece numerele în baza 10, să se determine suma celor două numere (tot în baza 2). Cifrele numerelor sunt date în ordinea descrescătoare a puterilor lui 2.

Observaţii:Completăm numărul mai scurt cu zerouri la stânga pentru a aduce cele două numere la aceeaşi lungime, apoi adunăm cele două numere cifră cu cifră, de la dreapta la stânga ţinând cont de transport.

#include<stdio.h>

66



int x[50],y[50],z[50],m,n,i,j,t,max,st=1;printf("m="); scanf("%d",&m);for(i=1;i<=m;i++){

printf("x[%d]=",i); scanf("%d",&x[i]);}printf("n="); scanf("%d",&n);for(i=1;i<=n;i++){

printf("y[%d]=",i); scanf("%d",&y[i]);}max=m>n? m: n; //lungimea maximă a numerelort=max-m; //câte cifre 0 trebuie adăugate la xfor(i=1;i<=t;i++){

//deplasăm vectorul x spre dreapta cu t //poziţii şi inserăm t zerouri la începutfor(j=m+1;j>=2;j--) x[j]=x[j-1];x[1]=0; m++;

}t=max-n; //câte cifre 0 trebuie adăugate la yfor(i=1;i<=t;i++){

//deplasăm vectorul y spre dreapta cu t //poziţii şi inserăm t zerouri la începutfor(j=n+1;j>=2;j--) y[j]=y[j-1];y[1]=0; n++;

}t=0; //transportul iniţial către rangul superiorfor(i=max;i>=1;i--){

z[i]=(x[i]+y[i]+t)%2;t=(x[i]+y[i]+t)/2; //transportul curent

}if(t==1) //suma numerelor are max+1 cifre{ z[0]=1; st=0; } //prima cifră este in z[0]printf("\n\t Suma celor doua numere este:\n");for(i=st;i<=max;i++) printf("%d",z[i]);printf("\n"); getch();

}

22. Se dă un vector cu n (1<=n<=100) componente naturale. Să se afişeze cea mai lungă secvenţă formată din elemente consecutive în ordine crescătoare. Exemplu: pentru n=7 şi vectorul 2, 33, 1, 4, 5, 3, 12 se va afişa 1, 4, 5.

Observa ţii: Pentru a putea analiza şi ultima secvenţă din vector, vom adăuga elementul a[n+1]=a[n]. Primul element face parte dintr-o secvenţă care iniţial are lungimea 1. La fiecare pas comparăm elementul curent a[i] cu elementul precedent a[i-1]. Dacă este mai mare, secvenţa îşi păstrează monotonia şi creştem lungimea secvenţei monotone curente. În caz contrar, secvenţa monotonă anterioară s-a încheiat cu elementul a[i-1] având lungimea lung. Verificăm dacă lungimea acesteia este mai mare decât lungimea maximă curentă lmax şi, eventual, actualizăm acest maxim şi poziţia de început pmax. În poziţia i începe o nouă secvenţă monotonă care deocamdată are lungimea 1.


int a[100],n,i,poz,lung,pmax,lmax;printf("n="); scanf("%d",&n);

67


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

printf("a[%d]=",i); scanf("%d",&a[i]);}a[n+1]=a[n]; //santinela//considerăm că prima secvenţă începe în poziţia 1//are lungimea 1 şi este iniţial de lungime maximăpoz=1; lung=1; pmax=1; lmax=1;for(i=2;i<=n+1;i++)

if(a[i]>a[i-1])//creşte lungimea secvenţei curente

lung++;else//s-a încheiat o secvenţă pentru care //verificăm lungimea{

if(lung>lmax) //actualizăm valorile{

lmax=lung; pmax=poz;}//în poziţia i începe o nouă secvenţă//cu lungimea iniţială 1poz=i; lung=1;

}printf("\n cea mai lunga seceventa de elemente

consecutive in ordine crescatoare este:\n");for(i=pmax;i<=pmax+lmax-1;i++) printf("%d ",a[i]);printf("\n"); getch();

}

23. Se dau vectorii x şi y cu câte n (1<=n<=100) elemente numere naturale nenule. Să se determine numerele p şi q prime între ele astfel încât: p/q=x[1]/y[1]+x[2]/y[2]+..+x[n]/y[n].

Observa ţii: Rezolvarea problemei se bazează pe următoarele raţionamente matematice:

Vom calcula numitorul comun al fracţiei (T) şi apoi numărătorul ca suma elementelor de forma x[i]*numitor/y[i]. Vom calcula c.m.m.d.c al celor două numere întregi obţinute şi vom simplifica numitorul şi numărătorul cu c.m.m.d.c. obţinând numărătorul şi numitorul fracţiei ireductibile echivalente.


int x[50],y[50],n,i,numitor=1,numarator=0,c,d,p,q; printf("n="); scanf("%d",&n);

printf("\t primul vector:\n");for(i=1;i<=n;i++)

{ printf("x[%d]=",i); scanf("%d",&x[i]); } printf("\t al doilea vector:\n"); for(i=1;i<=n;i++) { printf("y[%d]=",i); scanf("%d",&y[i]); numitor*=y[i]; //numitorul fractiei }

//calculăm numărătorul fracţiei sumă

68


for(i=1;i<=n;i++) numarator+=x[i]*numitor/y[i]; //determinăm c.m.m.d.c prin scăderi repetate

c=numitor; d=numarator; while(c!=d) if(c>d) c-=d; else d-=c;

//simplificăm numitorul şi numărătorul fracţiei p=numarator/c; q=numitor/c; printf("p=%d\tq=%d\n",p,q);

getch();}

24. Fie a un şir cu n elemente întregi, n<=100. Să se rearanjeze elementele lui a, fără a folosi memorie suplimentară, astfel încât cele pare să apară înaintea celor impare şi în aceeaşi ordine în care erau în vectorul iniţial.

Observaţii:Vom parcurge vectorul element cu element de la stânga spre dreapta. Dacă elementul curent a[i] este par, el îşi păstrează poziţia şi avansăm la următorul element. Dacă este impar, îl mutăm la sfârşitul vectorului, în poziţia n, deplasând toate elementele de după a[i] cu o poziţie spre stânga. Pentru a sesiza momentul în care partiţionarea vectorului s-a încheiat folosim o variabilă k, iniţial egală cu n, care scade la fiecare mutare a unui element impar la sfârşitul vectorului. În momentul în care cele două valori i şi k devin egale, partiţionarea vectorului s-a încheiat.


int a[50],n,i,j,k,aux; printf("n="); scanf("%d",&n);

for(i=1;i<=n;i++) { printf("a[%d]=",i); scanf("%d",&a[i]); }

i=1; k=n; do{ if(!(a[i]&1)) i++; //element par,avansăm else { //element impar,îl mutăm în poziţia n

aux=a[i]; for(j=i;j<=n-1;j++) a[j]=a[j+1]; a[n]=aux; k--; } }while(i<k); printf("\n\t Vectorul obtinut este:\n"); for(i=1;i<=n;i++) printf("%d ",a[i]);

printf("\n"); getch();}

25. Se dă o secvenţă de n numere naturale, n<=50 , şi un număr natural lim. Să se insereze între oricare două componente vecine a căror diferenţă în modul este mai mare sau egală cu lim , partea întreagă a mediei lor aritmetice.

Observaţii:Parcurgem vectorul începând cu primul element şi comparăm vecinii (a[i],a[i+1]). Dacă diferenţa lor în modul este mai mică decât lim avansăm la elementul următor. În caz contrar, calculăm media aritmetică a celor două elemente, deplasăm cu o poziţie spre dreapta secvenţa a[i+1].....a[n], inserăm în poziţia i+1 media calculată, actualizăm lungimea şirului (care creşte cu un element) şi trecem la elementul următor care este a[i+2] (sărim peste media tocmai introdusă în şir).

#include<stdio.h>#include<math.h>#include<conio.h>

69


void main(){

int a[100],n,i,j,lim,t; printf("n="); scanf("%d",&n);

for(i=1;i<=n;i++) { printf("a[%d]=",i); scanf("%d",&a[i]); }

printf("lim="); scanf("%d",&lim);i=1;

do{ if(abs(a[i]-a[i+1])<lim) i++;

//nutrecem la elementul următor else { //calculăm nedia aritm. a elem. vecine

t=(a[i]+a[i+1])/2;//deplasăm spre dreapta secvenţa

for(j=n+1;j>=i+2;j--) a[j]=a[j-1];

//inserăm în poziţia i+1 media aritm.//actualizăm lungimea şirului//şi sărim peste media introdusă

a[i+1]=t; n++; i+=2; } }while(i<n); printf("\n\t Vectorul obtinut este:\n"); for(i=1;i<=n;i++)

printf("%d ",a[i]); printf("\n"); getch();

}

26. N pitici aşezaţi unul în spatele celuilalt, poartă căciuli colorate roşii sau albe. Fiecare pitic spune două numere, primul reprezentând numărul de căciuli albe, celălalt numărul de căciuli roşii pe care le poartă piticii din faţa sa. a) Ştiind că piticii cu căciulă roşie mint (dau incorect cel puţin unul din cele două numere) ,

iar cei cu căciulă albă spun întotdeauna adevărul , să se determine culoarea căciulii fiecărui pitic. Se vor citi de la tastatură numărul n de pitici (n<=100) şi cele n perechi de numere. Se va tipări pe ecran o succesiune de litere A şi R reprezentând culorile căciulilor piticilor în ordinea în care stau în şir

b) Ştiind că fiecare pitic îşi păstrează culoarea căciulii determinată la punctul (a) , să se afle dacă este posibilă schimbarea ordinii piticilor în şir astfel încât toţi piticii să spună adevărul. În caz afirmativ, se vor tipări numerele de ordine iniţiale ale piticilor în noua ordine stabilită.

Observaţii: Primul punct se rezolvă analizând succesiv afirmaţiile fiecărui pitic. Dacă spune adevărul are căciulă albă, altfel are căciulă roşie. Pentru al doilea punct determinăm pe rând perechile de numere care au suma (adică numărul de pitici aflaţi în faţă) 0, apoi 1, apoi 2,..,până la n-1, condiţia de existenţă a soluţiei fiind ca la fiecare pas să existe o astfel de pereche şi piticul corespunzător să spună adevărul (să aibă căciulă albă).


int a[100],r[100],n,i,j,k,na,nr;char sir[101];printf("n="); scanf("%d",&n);na=0; nr=0; for(i=1;i<=n;i++){

printf("raspunsul piticului %d (alb,rosu):

70


",i);scanf("%d %d",&a[i],&r[i]);if(na==a[i] && nr==r[i]){

na++; sir[i]='A'; //spune adevărul}else{

nr++; sir[i]='R'; //minte}

}printf("\n\t Caciulile piticilor sunt:\n");for(i=1;i<=n;i++) printf("%c ",sir[i]);printf("\n");printf("punctul b)\n");na=0; nr=0; i=0;do{

j=0;for(k=1;k<=n;k++)

if(a[k]+r[k]==i && na==a[k] && nr==r[k]) j=k;

printf("%d ",j);if(j)

if(sir[j]=='A') na++; else nr++;

i++;}while(j && i<n);if(!j)

printf("\nNu exista solutie\n");else

printf("\n");getch();

}

27. Fiind date n segmente (intervale deschise) situate pe aceeaşi axă, se cere colorarea lor cu un număr minim de culori astfel încât oricare două segmente care se intersectează să aibă culori diferite. Fiecare interval este dat pe o linie sub forma unei perechi de numere întregi din intervalul [1,1000], primul număr fiind întotdeauna mai mic decât al doilea.

Observaţii:Problema se reduce la determinarea numărului maxim de segmente care se suprapun. Axa pe care sunt scrise segmentele este un vector (linie). Fiecare segment se colorează adunând la elementele sale valoarea 1. Iniţial toate elementele sunt 0 adică necolorate.


int linie[10001],n,i,j,a,b,max;//iniţializăm culoarea punctelor din intervalul//[1..1000] cu 0for(i=1;i<=1000;i++) linie[i]=0;//citim numărul intervalelorprintf("n="); scanf("%d",&n);for(i=1;i<=n;i++){

//citim extremităţile fiecărui interval [a,b]printf("[a,b]="); scanf("%d %d",&a,&b);//creştem cu 1 culoarea punctelor din //intervalul [a,b]for(j=a+1;j<=b;j++) linie[j]++;

}max=0;//culoarea maximă din tablou reprezintă numărul

71


//intervalelor care se intersecteazăfor(i=1;i<=1000;i++)

if(max<linie[i]) max=linie[i];printf("\nnumarul minim de culori necesare este

%d\n",max);getch();

}

28. Se citesc de la tastatură două numere naturale de cel mult cinci cifre fiecare. Să se afişeze valoarea exactă a raportului lor folosind un număr minim de caractere.

Observaţii:Cunoscând algoritmul împărţirii numerelor naturale din aritmetică, vom simula împărţirea în program coborând zecimalele deîmpărţitului (zerouri) cifră cu cifră. Înţelegând prin cerinţa „număr minim de caractere” că pentru numerele zecimale infinite (obligatoriu periodice deoarece provin din fracţii de numere întregi, deci din numere raţionale) se va folosi reprezentarea lor cu perioada principală între paranteze, vom avea grijă să memorăm resturile parţiale ale împărţirilor pentru a sesiza când se repetă unul dintre resturi.


unsigned char c[10000];unsigned r[10000],i,j,k,a,b,poz;printf("numerele a,b: "); scanf("%u %u",&a,&b);if(!b){

printf("raport cu numitorul 0!\n");return;

}printf("\nValoarea zecimala a raportului este: ");printf("%u",a/b);if(a%b) //restul este nenul{

putchar('.'); i=0; poz=0;do{

a%=b; //restul curentfor(j=1;j<=i;j++)

if(r[j]==a) //restul se repetă{

poz=j; break; //memorăm poziţia

}i++; r[i]=a; //memorăm restul curenta*=10;

//coborâm un zero din deîmpărţitc[i]=a/b;

//memorăm cifra curentă a rezultatului}while(a&&!poz);//până se împarte exact sau se obţine un rest

//care a mai apărutif(poz) //număr periodic{

for(k=1;k<=poz-1;k++) printf("%d",c[k]);

printf("(");for(k=poz;k<=i-1;k++)

printf("%d",c[k]);printf(")\n");

}else //număr neperiodic{

for(k=1;k<=i;k++) printf("%d",c[k]);

72


printf("\n");

}}getch();

}

B. Probleme propuse

1. Să se construiască un vector cu primele n (1<=n<=20) numere cuburi perfecte nenule, apoi să se afişeze componentele lui cu spaţiu între ele.

2. Scrieţi un program care citeşte de la tastatură cele n componente reale ale unui vector a (1<=n<=100) şi afişează pe ecran câte dintre valorile citite sunt mai mici decât media aritmetică a elementelor vectorului.

3. Scrieţi un algoritm eficient care determină şi afişează cel mai mare număr ce se poate forma având exact aceleaşi cifre ca şi un număr natural n citit de la tastatură (n<=999 999 999).

4. Se citeşte de la tastatură un vector cu n (1<=n<=100) componente reale. Se cere să se calculeze suma componentelor negative, produsul componentelor pozitive şi numărul componentelor nule.

5. Se citeşte de la tastatură un vector cu n (1<=n<=100) componente de tip întreg. Se cere să se construiască şi să se afişeze un nou vector cu componentele pătrate perfecte din vectorul iniţial. Dacă nu există componente pătrate perfecte, se va afişa mesajul “VECTOR VID”.

6. Fără a folosi un vector auxiliar, să se mute la sfârşitul unui vector componentele sale nule, păstrându-se ordinea acestora. Se ştie că vectorul are n (1<=n<=100) componente numere naturale.

7. Se dă un vector x cu n (1<=n<=100) componente numere întregi. Se cere să se determine componentele distincte din x împreună cu frecvenţa lor de apariţie.

8. Să se treacă un număr natural n (1<=n<=1000000) din baza 10 în baza 2 folosind pentru memorarea cifrelor numărului binar un vector.

9. Să se treacă un număr natural cu n (1<=n<=26) cifre din baza 2 în baza 10. Cifrele numărului sunt date în vectorul x în ordinea descrescătoare a puterilor lui 2.

10. Se dă un vector cu n (1<=n<=100) componente numere naturale. Să se construiască şi să se afişeze un nou vector cu componentele pare ale celui iniţial.

11. Se dau doi vectori x, y cu n (1<=n<=100) componente. Primul conţine nume de elevi, iar al doilea notele la informatică. Se cere să se afişeze numele elevilor cu nota cea mai mică.

12. Să se calculeze suma şi produsul componentelor unui vector cu n (1<=n<=100) componente reale.

13. Se dau doi vectori x,y cu n (1<=n<=100) componente întregi. Să se determine valoarea expresiei: x[1]y[1]+x[2]y[2]+….+x[n]y[n].

14. Se dau doi vectori x,y cu n (1<=n<=100) componente reale. Să se calculeze sumele: x[1]*y[1]+….+x[n]*y[n], respectiv x[n]*y[1]+x[n-1]*y[2]+…+x[1]*y[n].

15. Se dă un vector cu n (1<=n<=100) componente naturale. Să se calculeze suma elementelor divizibile cu a, pentru a număr natural dat.

16. Se dă un vector cu n (1<=n<=100) componente numere naturale. Să se insereze între oricare două componente alăturate media aritmetică a celorlalte n-2 componente.

17. Se dă un vector cu n (1<=n<=100) componente întregi. Se cere să se afişeze primele k componente în ordine crescătoare iar celelalte în ordine descrescătoare.

18. Se dă un vector cu n (1<=n<=100) componente naturale. Să se afişeze componenta care apare de cele mai multe ori în vector. Dacă există mai multe astfel de componente se vor afişa toate.

19. Să se determine cel mai mare divizor comun şi cel mai mic multiplu comun a n numere naturale.

20. Se dă un vector cu n (1<=n<=100) componente întregi. Să se verifice dacă reprezintă o mulţime în sens matematic (valorile nu se repetă).

21. Se dă un şir cu n elemente reale, n<=100 . Să se determine cel mai mare număr negativ şi poziţiile pe care se află el în şirul dat.

73


22. Fie a un vector cu n numere reale, n<=100. Să se afle cea mai mare diferenţă în modul dintre două componente ale sale. Să se modifice vectorul astfel încât cele două componente să fie consecutive.

23. Se citesc doi vectori, a cu m elemente şi b cu n elemente, m,n<=150, numere întregi. Să se verifice dacă cei doi vectori sunt mulţimi în sens matematic şi , în caz afirmativ, să se calculeze intersecţia şi reuniunea lor.

24. Să se stabilească dacă o valoare dată y se află printre componentele unui vector de numere întregi şi, în caz afirmativ, să se tipărească toate poziţiile în care apare printr-o singură parcurgere a vectorului.

25. Fie a un vector cu n elemente reale, n<=100. Să se înlocuiască fiecare element cu media aritmetică a celorlalte n-1 elemente.

26. Fie a un şir cu n elemente întregi, n<=100. Să se determine elementul maxim din şir şi toate poziţiile în care acesta apare printr-o singură parcurgere a şirului.

27. Fie a un vector de n numere reale, n<=150. Să se determine printr-o singură parcurgere a sa cea mai lungă secvenţă de elemente consecutive egale. Se va preciza lungimea şi poziţia de început a primei astfel de secvenţe fără a folosi memorie suplimentară.

28. Fiind dat un număr natural având cel puţin k cifre (k<=20), se cere să se elimine din număr k cifre astfel încât numărul rămas să fie cel mai mare posibil.

29. Se dă un şir de n numere reale, n<=250. Să se scrie un program care determină ce element se află pe poziţia k dată în şirul ordonat, fără a face efectiv ordonarea şi fără a folosi memorie suplimentară. (0<=k<=n-1).

30. Se dau n pioni de culoare albă, albastră şi roşie. Şirul se consideră ordonat parţial: primele k-1 poziţii sunt ocupate cu pioni roşii, poziţiile de la k la l-1 de pioni albi, poziţiile de la l la m-1 de pioni albaştri şi poziţiile de la m la n de pioni neordonaţi (1<=k<=l<=m<=n). Să se scrie un program care plasează pionii neordonaţi în şirul ordonat. Plasarea lor se face prin schimbarea pionilor între ei. Culoarea unui pion se analizează o singură dată. Se va folosi o singură locaţie de memorie suplimentară.

31. Fie a un număr real şi x un vector cu n elemente reale, n<=100. Să se rearanjeze elementele lui x astfel încât toate numerele mai mici decât a să fie înaintea tuturor numerelor mai mari sau egale cu a, fără a ordona efectiv şirul.

32. Fie a un număr real şi vectorul x cu n elemente reale, n<=100. Să se elimine din şir toate elementele mai mici decât a fără a folosi memorie suplimentară.

33. Fie a un număr real şi x un vector cu n numere reale, n<=100. Să se ordoneze vectorul crescător după distanţa lor faţă de numărul a.

34. Dacă X este şirul : 1,1,2,1,2,3,1,2,3,4,…… obţinut din şirul numerelor naturale prin înlocuirea fiecărui k natural cu secvenţa de numere 1,2,3,…,k , să se construiască vectorul V(n) cu componente egale cu primii n termeni ai şirului X , n<=250, dat.

35. Fie a un vector cu n numere întregi, n<=100. Să se interschimbe două secvenţe de lungime L1 şi L2 care încep din poziţiile p1, respectiv p2. Elementele care nu sunt cuprinse în cele două secvenţe pot fi mutate astfel încât interschimbarea să se poată face.Exemplu : n=9 A=(1,2,3,4,5,6,7,8,9) P1=2 , L1=2 P2=6 , L2=3 a=(1,6,7,8,4,5,2,3,9)

36. Se dă un vector numeric cu n elemente. Să se determine cea mai lungă secvenţă de elemente consecutive din şir cu proprietatea că doi vecini au semne diferite.

37. La o adunare a oamenilor de afaceri s-a propus înfiinţarea de către un grup de investitori a unei societăţi comerciale cu un capital de pornire c, dat. Cunoscând suma de care dispune fiecare din cei n oameni de afaceri, să se aleagă acele persoane care totalizează suficient capital pentru a putea înfiinţa societatea şi în acelaşi timp să formeze un grup cât mai restrâns (pentru ca posibilităţile de a interveni neînţelegeri între ei să fie cât mai reduse).

38. Fie n puncte în plan date prin coordonatele lor carteziene (xi,yi) numere reale.Să se afişeze coordonatele şi mărimea celui mai lung segment obţinut prin unirea a două puncte din cele n.

39. Se citeşte un număr natural foarte mare (maxim 100 de cifre). Să se verifice dacă este palindrom.

40. Se consideră două numere naturale cu câte maxim 50 de cifre oarecare, cifrele fiind date în ordinea descrescătoare a rangurilor. Să se afişeze suma celor două numere.

41. Se consideră două tablouri cu m, respectiv n componente reale (1<=m,n<=100). Se citeşte un număr natural k. Să se insereze în primul tablou, după poziţia k, tabloul al doilea.

74


42. Se consideră două tablouri cu m, respectiv n elemente reale, care reprezintă coeficienţii a două polinoame P(x) şi Q(x) în ordinea descrescătoare a gradelor lui x. Să se afişeze coeficienţii polinomului sumă.

43. Dându-se un tablou cu n (1<=n<=100) numere naturale, să se afişeze numai elementele care sunt prime sau fac parte din şirul Fibonacci.

44. Dându-se un tablou cu n (1<=n<=100) numere naturale, să se localizeze elementul maxim şi toate elementele dinaintea lui să se ordoneze crescător, iar cele de după el, descrescător, afişându-se rezultatul.

45. Să se calculeze 2n, unde n este un număr natural citit, de valoare maximă 100, astfel încât să se afişeze rezultatul corect. Apoi să se afişeze fracţia zecimală care rezultă din 1/2n.

46. Fiind date n (1<=n<=100) numere întregi şi un număr k, să se determine dacă există o secvenţă de k elemente consecutive a căror valoare este 0.

47. Fiind date n (1<=n<=100) numere întregi, să se numere perechile de numere de pe poziţii consecutive care au valori a căror diferenţă în modul este egală cu 1.

48. Fiind date două tablouri a şi b cu n, respectiv m elemente, scrieţi un program care să verifice dacă au aceleaşi elemente distincte (toate elementele unui vector se găsesc printre elementele celuilalt vector şi invers). Exemplu: a=(2,3,2,2,4,1) şi b=(2,4,2,4,1,3) au aceleaşi elemente distincte (1,2,3,4).

49. Se consideră doi vectori a şi b, cu n, respectiv m elemente numere întregi (1<=n<=m<=100). Să se verifice dacă elementele vectorului a sunt printre elementele vectorului b, în aceeaşi ordine, dar nu neapărat consecutive.

50. Fiind dat un tablou cu n (1<=n<=100) numere întregi, să se determine numărul elementelor prime cu un număr natural k dat.

51. Cunoscându-se lungimea unui şir şi componentele sale, să se tipărească o secvenţă de lungime maximă de elemente consecutive care formează o progresie aritmetică. Exemplu: pentru şirul (5,2,15,23,2,4,6,-1,33.5,81,21,-19) sunt corecte secvenţele (2,4,6) şi (81,21,-19).

52. Se citesc n numere naturale. Să se determine din câte secvenţe monotone este format şirul dat şi să se tipărescă fiecare secvenţă. Prin secvenţă monotonă se înţelege un şir de termeni consecutivi care sunt, fie în ordine crescătoare, fie în ordine descrescătoare. Exemplu: şirul (2,8,12,4,20,24,30,5,3,1,1,0) este format din 3 secvenţe monotone şi anume (2,8,12), (4,20,24,30), (5,3,1,1,0) primele două fiind crescătoare şi a treia descrescătoare.

53. Fiind dat un vector cu n numere reale (1<n<=100) să se verifice dacă toate elementele vectorului sunt constante (egale două câte două).

54. Fiind date n segmente (intervale închise) situate pe aceeaşi axă, date prin extremităţile lor, să se determine intersecţia celor n intervale.

55. Fiind dat un vector cu n elemente întregi, să se separe elementele astfel: cele pozitive la începutul vectorului, iar cele negative la sfârşit. Se va păstra ordinea de apariţie a elementelor pozitive, respectiv negative în vector şi nu se va utiliza memorie suplimentară.

56. Să se elimine elementele impare dintr-un vector cu n numere naturale nenule fără a folosi memorie suplimentară.

57. Scrieţi un program eficient care determină câte valori distincte de cel mult două cifre există într-un şir de n numere naturale (n<=2000) citite de la tastatură.

58. Se citesc două şiruri de numere naturale fiecare având n elemente. Să se construiască un şir care conţine pe fiecare poziţie suma elementelor corespunzătoare celor două şiruri date şi să se tipărească elementele acestuia în ordine crescătoare.

59. Pentru n numere date se calculează media aritmetică şi două valori procentuale cu o zecimală: procentul de numere dintre cele date care sunt strict mai mici decât media aritmetică a întregului şir şi procentul de numere care sunt strict mai mari decât media aritmetică.

60. Scrieţi un program eficient care determină toate perechile de numere naturale a şi b, cu a<=b, numerele ce formează perechea având proprietatea că nu au nici o cifră comună şi suma lor este s. Valoarea s este un număr natural citit de la tastatură (s<100 000 000).

61. Scrieţi un program eficient care citeşte n valori naturale de cel mult 5 cifre fiecare (0<n<1000) şi afişează cea mai mică valoare de exact trei cifre care nu apare printre cele n valori. Dacă nu există nici-un astfel de număr se va afişa mesajul EROARE. De exemplu, pentru n=8 şi valorile (1238, 511, 104, 60, 101, 7000, 100, 44) se va afişa 102.

62. Scrieţi un program care citeşte de la tastatură o valoare naturală n (0<n<200) şi apoi cele n componente numere întregi ale vectorului v, orice element al vectorului având cel mult patru cifre. Să se realizeze sortarea crescătoare a elementelor pare ale vectorului având grijă ca în plus fiecare element impar să rămână exact pe poziţia pe care se afla iniţial. Pentru n=7 şi vectorul v=(10,2,5,11,6,5,8) se va afişa şirul de valori 2 6 5 11 8 5 10.

75

Cap · Web view2014-10-12 · ... 12. b+=c+d+a este : 20. ... Exemplu: pentru n=7 şi vectorul 2,...

Documents

Transcript of Cap · Web view2014-10-12 · ... 12. b+=c+d+a este : 20. ... Exemplu: pentru n=7 şi vectorul 2,...