PCLP Laborator 9 PDF

LABORATOR 9
N.B. Laboratorul 9 cuprinde întrebările din Cursurile 4-6 care vor apare pe biletele de la examen.
ÎNTREBĂRI CURS 4: Aplicații cu numere și tablouri de caractere. Funcţii. Variabile. Tipuri de date.
Constante
1. În programul de mai jos, în suma(x,y); x şi y reprezintă ….

#include <stdio.h>
int suma(int ,int );
int main(){
int x = 3, y = 4, adunare;
adunare = suma(x, y);
printf("suma = %d\n",adunare);
return 0;
}
int suma(int a, int b){
int s;
s = a + b;
return s;
}
a. parametrii actuali sau efectivi b. parametrii formali sau efectivi
c. parametrii formali d. variabile automate
2. În codul funcţiei suma de mai jos, primul cuvânt int, reprezintă ….

int s;
s = a + b;
return s;
}
a. tipul variabilelor locale b. tipul valorii returnate de funcţie
c. tipul parametrilor de intrare d. valoarea returnată de funcţie
3. În codul funcţiei suma de mai jos, a şi b, reprezintă …..

int s;
s = a + b;
return s;
}
a. parametrii formali de ieşire b. valorile returnate de funcţie
c. parametrii formali de intrare d. parametrii efectivi de intrare
4. Parametrii actuali şi cei formali trebuie să corespundă ca ……….

a. tip de dată şi clasă de alocare b. poziţie, număr şi nume
c. tip de dată, adresă de memorie, nume şi valoare d. poziţie, număr şi tip de dată
5. Parametrii …. substituie la apel parametrii …...

a. actuali formali b. formali actuali c. formali efectivi d. actuali efectivi
6. O variabilă automată apare când funcţia este apelată şi …… când se iese din funcţie.
a. îşi păstrează valoarea b. dispare c. devine zero d. nu dispare
7. Variabilele automate sunt externe tuturor funcţiilor.

a. numai dacă sunt şi statice b. adevărat c. dacă sunt declarate în afara tuturor funcţiilor d. fals
1
8. Pentru o variabilă externă valoarea ei de dinainte de apelul unei funcţii care o modifică şi se termină ….
a. se păstrează b. se pierde c. devine incertă d. devine zero
9. O variabilă externă trebuie definită o singură dată în afara oricărei funcţii şi apoi obligatoriu declarată în
fiecare funcţie care doreşte să o acceseze.
a. adevărat b. fals
c. adevărat doar pentru variabilele declarate explicit cu extern d. variantele a, b, c sunt toate false
10. O variabilă locală dintr-o funcţie care apare numai când funcţia este apelată şi dispare când se iese din
funcţie se numeşte variabilă ………….
a. externă b. internă c. automată d. statică
11. O variabilă care este accesibilă tuturor funcţiilor şi îşi reţine valoarea chiar după ce funcţiile care au
modificat-o au returnat-o se numeşte variabilă ………….
a. statică b. dinamică c. automată d. externă
12. Pentru o variabilă externă ….. se referă la locul unde variabila este creată sau i se asociază spaţiu de stocare
în memoria calculatorului.
a. definirea b. declararea c. memorarea d. atribuirea
13. Pentru o variabilă externă ….. se referă la locurile unde este specificată natura variabilei, dar nu i se aloca
spaţiu de memorie.
a. definirea b. declararea c. iniţializarea d. atribuirea
14. În programul de mai jos suma(x,y); reprezintă ….

#include <stdio.h>
int suma(int ,int );
int main(){
int x = 3, y = 4, adunare;
adunare = suma(x, y);
printf("suma = %d\n",adunare);
return 0;
}
int s;
s = a + b;
return s;
}
a. declaraţia funcţiei suma b. apelul funcţiei suma c. prototipul funcţiei suma d. definiţia funcţiei suma
15. O variabilă locală este o variabilă ….

a. statică b. dinamică c. automată d. formală
16. Programul următor citește un număr n natural (n>1) și afișează dacă este prim sau nu. Exemple: n = 17 =>
17 e prim; n = 77 => 77 nu e prim. Programul conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită
și varianta ei corectă pentru ca programul să funcționeze corespunzător.
#include <stdio.h>
main()
{
int n, i, prim = 0;
printf("Dati numarul = ");
scanf("%d",&n);
for ( i = 2; i <= n - 1; ++i )
if ( n%i == 0 ){
prim = 0;
break;
}
if ( prim )
printf("%d e prim\n", n);
2
else
printf("%d nu e prim\n", n);
}
R. int n, i, prim = 0; corect este int n, i, prim = 1;
17 e prim; n = 77 => 77 nu e prim. Completați punctele de suspensie cu instrucțiunea corespunzătoare pentru
ca programul să funcționeze corect.
#include <stdio.h>
main()
{
int n, i, prim = 1;
scanf("%d",&n);
for ( i = 2; i <= n - 1; ++i )
if ( n%i == 0 )
..........
if ( prim )
else
}
R. prim = 0;
18. Ce afișează programul următor dacă se citește de la tastatură n = 25 ?

#include <stdio.h>
main()
{
int n, i, x = 1;
printf("n = ");
scanf("%d",&n);
for ( i = 2; i <= n - 1; ++i )
if ( n%i == 0 )
x = 0;
if ( x )
printf("1\n");
else
printf("0\n");
}
R. 0
19. Ce număr natural n (n>1) trebuie să citim de la tastatură astfel încât programul să afișeze 1 ?
#include <stdio.h>
main()
{
int n, i, x = 1;
scanf("%d",&n);
for ( i = 2; i <= n - 1; ++i )
if ( n%i == 0 ){
x = 0;
break;
}
if ( x )
printf("1\n");
else
printf("0\n");
}
R. orice număr prim

3
20. Precizați scopul programului de mai jos?
#include <stdio.h>
main()
{
int n, i, x = 1;
scanf("%d",&n);
for ( i = 2; i <= n - 1; ++i )
if ( n%i == 0 ){
x = 0;
break;
}
if ( x )
printf("1\n");
else
printf("0\n");
}
R. testează dacă un număr n citit este prim (afișând 1) sau nu e prim (afișând 0)
21. Programul următor citește un număr n natural și afișează dacă este prim sau nu. Exemple: n = 17 => 17 e
prim; n = 77 => 77 nu e prim; n = 0 => 0 nu e prim; n = 1 => 1 nu e prim. Programul conține o instrucțiune
scrisă greșit. Scrieți instrucțiunea greșită și varianta ei corectă pentru ca programul să funcționeze
corespunzător.
#include <stdio.h>
main()
{
int n, i, prim = 1;
printf("n = ");
scanf("%d",&n);
if( n == 0 || n == 1 )
prim = 0;
else
for ( i = 2; i <= n - 1; ++i )
if ( i%n == 0 ){
prim = 0;
break;
}
if ( prim )
else
}
R. if ( i%n == 0 ) corect este if ( n%i == 0 )
22. Programul următor citește un număr n natural și afișează dacă este prim sau nu.. Exemple: n = 17 => 17 e
corespunzător.
#include <stdio.h>
main()
{
int n, i, prim = 1;
printf("n = ");
scanf("%d",&n);
if( n == 0 || n == 1 )
prim = 0;
else
for ( i = 1; i <= n - 1; ++i )
if ( n%i == 0 ){
prim = 0;
4
break;
}
if ( prim )
else
}
R. for(i = 1; i<=n-1; ++i ) corect este for(i=2; i<=n-1; ++i )
corespunzător.
#include <stdio.h>
main()
{
int n, i, prim = 1;
printf("n = ");
scanf("%d",&n);
if( n == 0 || n == 1 )
prim = 0;
else
for ( i = 2; i <= n; ++i )
if ( n%i == 0 ){
prim = 0;
break;
}
if ( prim )
else
}
R. for(i=2; i<=n; ++i) corect este for(i=2; i<n; ++i)
prim; n = 77 => 77 nu e prim; n = 0 => 0 nu e prim; n = 1 => 1 nu e prim. Completați punctele de suspensie
cu caracterele corespunzătoare pentru ca programul să funcționeze corect.
#include <stdio.h>
main()
{
int n, i, prim = 1;
scanf("%d",&n);
if( ....... )
prim = 0;
else
for ( i = 2; i <= n - 1; ++i )
if ( n%i == 0 ){
prim = 0;
break;
}
if ( prim )
else
}
R. n == 0 || n == 1 sau n<2 sau n<=1
5
17 e prim; n = 77 => 77 nu e prim. Programul conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită
#include <stdio.h>
#include <math.h>
main()
{
int n, i, prim = 1;
scanf("%d",&n);
if( n%2 == 1)
prim = 0;
else
for ( i = 3; i <= sqrt(n); i = i + 2 )
if ( n%i == 0 ){
prim = 0;
break;
}
if ( prim )
else
}
R. if( n%2 == 1) corect este if( n%2 == 0)
26. Programul următor citește un număr n natural (n>1) și afișează dacă este prim sau nu evitând valorile pare
din testul de divizibilitate. Exemple: n = 17 => 17 e prim; n = 77 => 77 nu e prim. Completați punctele de
suspensie cu caracterele corespunzătoare pentru ca programul să funcționeze corect.
#include <stdio.h>
#include <math.h>
main()
{
int n, i, prim = 1;
scanf("%d",&n);
if( n%2 == 0)
prim = 0;
else
......................
if ( n%i == 0 ){
prim = 0;
break;
}
if ( prim )
else
}
R. for ( i = 3; i <= sqrt(n); i = i + 2 ) sau în loc de sqrt(n): n/2 sau n-1
27. Ce afișează programul următor dacă se citește de la tastatură 7 ?

#include <stdio.h>
#include <math.h>
main()
{
int n, i, x = 1;
printf("n = ");
scanf("%d",&n);
if( n%2 == 0)
x = 0;
else
6
for ( i = 3; i <= sqrt(n); i = i + 2 )
if ( n%i == 0 ){
x = 0;
break;
}
if ( x )
printf("1\n");
else
printf("0\n");
}
R. 1
28. Ce trebuie să citim pe intrare astfel încât programul să afișeze 0 ?

#include <stdio.h>
#include <math.h>
main()
{
int n, i, x = 1;
printf("n = ");
scanf("%d",&n);
if( n%2 == 0)
x = 0;
else
for ( i = 3; i <= sqrt(n); i = i + 2 )
if ( n%i == 0 ){
x = 0;
break;
}
if ( x )
printf("1\n");
else
printf("0\n");
}
R. orice număr ne-prim
29. Programul următor afișează toți divizorii unui număr n natural dat. Exemplu: n = 6 => 1, 2, 3, 6. Programul
conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și varianta ei corectă pentru ca programul să
funcționeze corespunzător.
#include <stdio.h>
main()
{
int n, i;
printf("n = "); scanf("%d",&n);
for ( i = 1; i < n; ++i )
if ( n%i == 0 )
printf("%d\n", i);
}
R. for ( i = 1; i < n; ++i ) corect este for ( i = 1; i <= n; ++i )
30. Programul următor afișează toți divizorii unui număr n natural dat. Exemplu: n = 6 => 1, 2, 3, 6.
Completați punctele de suspensie cu caracterele corespunzătoare pentru ca programul să funcționeze corect.
#include <stdio.h>
main()
{
int n, i;
for ( i = 1; ...... ; ++i )
if ( n%i == 0 )
printf("%d\n", i);
}
7
R. i <= n

#include <stdio.h>
main()
{
int n, i;
for ( i = 1; i <= n; ++i )
if ( n%i == 0 )
printf("%d", i);
}
R. 17

#include <stdio.h>
main()
{
int n, i;
scanf("%d",&n);
for ( i = 1; i <= n; ++i )
if ( n%i == 0 )
printf("%d", i);
}
R. 11

#include <stdio.h>
main()
{
int n, i;
for ( i = 1; i <= n; ++i )
if ( n%i == 0 )
printf("%d\n", i);
}
R. afișează toți divizorii unui număr natural dat
34. Programul următor afișează toți divizorii unui număr n natural dat. Exemplu: n = 12 => 1 12 2 6 3 4.
Programul conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și varianta ei corectă pentru ca
programul să funcționeze corespunzător.
#include <stdio.h>
#include <math.h>
main()
{
int n, i;
printf("n = ");
scanf("%d",&n);
for ( i = 1; i <= sqrt(n); ++i )
if ( n%i == 0 ) {
printf("%d ", i);
if ( n%i != i )
printf("%d ", n/i);
}
}
8
R. if ( n%i != i ) corect este if ( n/i != i )
#include <stdio.h>
#include <math.h>
main()
{
int n, i;
printf("n = ");
scanf("%d",&n);
for ( i = 1; i <= sqrt(n); ++i )
if ( n%i == 0 ) {
printf("%d ", i);
..............
printf("%d ", n/i);
}
}
R. if ( n/i != i )

#include <stdio.h>
#include <math.h>
main()
{
int n, i;
printf("n = ");
scanf("%d",&n);
for ( i = 1; i <= sqrt(n); ++i )
if ( n%i == 0 ) {
printf("%d\n", i);
if ( n/i != i )
printf("%d\n", n/i);
}
}
R. nimic

#include <stdio.h>
#include <math.h>
main()
{
int n, i;
printf("n = ");
scanf("%d",&n);
for ( i = 1; i <= sqrt(n); ++i )
if ( n%i == 0 ) {
printf("%d", i);
if ( n/i != i )
printf("%d", n/i);
}
}
R. 1122634

#include <stdio.h>
#include <math.h>
main()
{
9
int n, i;
printf("n = ");
scanf("%d",&n);
for ( i = 1; i <= sqrt(n); ++i )
if ( n%i == 0 ) {
printf("%d", i);
if ( n/i != i )
printf("%d", n/i);
}
}
R. 8

#include <stdio.h>
#include <math.h>
main()
{
int n, i;
printf("n = ");
scanf("%d",&n);
for ( i = 1; i <= sqrt(n); ++i )
if ( n%i == 0 ) {
printf("%d\n", i);
if ( n/i != i )
printf("%d\n", n/i);
}
}
R. afișează toți divizorii unui număr natural dat
...............
main()
{
int n, i;
printf("n = ");
scanf("%d",&n);
for ( i = 1; i <= sqrt(n); ++i )
if ( n%i == 0 ) {
printf("%d ", i);
if ( n/i != i )
printf("%d ", n/i);
}
}
R. #include <stdio.h> #include <math.h>
41. Programul următor afișează descompunerea în factori primi a unui număr natural n citit de la tastatură.
Exemplu: n = 360 => 2^3 * 3^2 * 5. Programul conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită
#include <stdio.h>
main()
{
int n, d, p;
printf("n = ");
scanf("%d",&n);
d = 1;
while ( n > 1 ){
if ( n%d == 0 ) {
p = 0;
while( n%d == 0 ){
++p;
10
n = n/d;
}
printf(p>1?"%d^%d":"%d", d, p);
if ( n > 1 )
printf(" * ");
}
++d;
}
}
R. d = 1; corect este d = 2;
#include <stdio.h>
main()
{
int n, d, p;
printf("n = ");
scanf("%d",&n);
d = 2;
while ( n > 1 ){
if ( n%d == 0 ) {
p = 1;
while( n%d == 0 ){
++p;
n = n/d;
}
printf(p>1?"%d^%d":"%d", d, p);
if ( n > 1 )
printf(" * ");
}
++d;
}
}
R. p = 1; corect este p = 0;
#include <stdio.h>
main()
{
int n, d, p;
printf("n = ");
scanf("%d",&n);
d = 2;
while ( n > 1 ){
if ( n%d == 0 ) {
p = 0;
while( n%d == 0 ){
++p;
n = n%d;
}
printf(p>1?"%d^%d":"%d", d, p);
if ( n > 1 )
printf(" * ");
}
++d;
}
}
11
R. n = n%d; corect este n = n/d;
Exemplu: n = 360 => 2^3 * 3^2 * 5. Completați punctele de suspensie cu caracterele corespunzătoare pentru ca
programul să funcționeze corect.
#include <stdio.h>
main()
{
int n, d, p;
printf("n = ");
scanf("%d",&n);
d = 2;
while ( n > 1 ){
if ( n%d == 0 ) {
p = 0;
while( n%d ==0 ){
++p;
.........
}
printf(p>1?"%d^%d":"%d", d, p);
if ( n > 1 )
printf(" * ");
}
++d;
}
}
R. n = n/d;
Exemplu: n = 360 => 2^3 * 3^2 * 5. Completați punctele de suspensie cu caracterele corespunzătoare pentru ca
#include <stdio.h>
main()
{
int n, d, p;
printf("n = ");
scanf("%d",&n);
d = 2;
while ( n > 1 ){
if ( n%d == 0 ) {
p = 0;
while( n%d ==0 ){
++p;
n = n/d;
}
printf(p>1?"%d^%d":"%d", d, p);
if ( n > 1 )
printf(" * ");
}
.......
}
}
R. ++d; sau d++; sau d = d + 1;

#include <stdio.h>
main()
{
int n, d, p;
12
printf("n = ");
scanf("%d",&n);
d = 2;
while ( n > 1 ){
if ( n%d == 0 ) {
p = 0;
while( n%d ==0 ){
++p;
n = n/d;
}
printf(p>1?"%d^%d":"%d", d, p);
if ( n > 1 )
printf(" * ");
}
++d;
}
}
R. 2^5 * 3

#include <stdio.h>
main()
{
int n, d, p;
printf("n = ");
scanf("%d",&n);
d = 2;
while ( n > 1 ){
if ( n%d == 0 ) {
p = 0;
while( n%d ==0 ){
++p;
n = n/d;
}
printf(p>1?"%d^%d":"%d", d, p);
if ( n > 1 )
printf(" * ");
}
++d;
}
}
R. 2^5 * 3

#include <stdio.h>
main()
{
int n, d, p;
printf("n = ");
scanf("%d",&n);
d = 2;
while ( n > 1 ){
if ( n%d == 0 ) {
p = 0;
while( n%d ==0 ){
++p;
n = n/d;
}
printf(p>1?"%d^%d":"%d", d, p);
if ( n > 1 )
printf(" * ");
}
13
++d;
}
}
R. nimic
49. Ce trebuie să citim pe intrare astfel încât programul următor să afișeze un singur număr prim ?
#include <stdio.h>
main()
{
int n, d, p;
printf("n = ");
scanf("%d",&n);
d = 2;
while ( n > 1 ){
if ( n%d == 0 ) {
p = 0;
while( n%d ==0 ){
++p;
n = n/d;
}
printf(p>1?"%d^%d":"%d", d, p);
if ( n > 1 )
printf(" * ");
}
++d;
}
}
R. acel număr prim care se dorește afișat
50. Ce număr natural trebuie să citim pe intrare astfel încât programul următor să nu afișeze nimic ?
#include <stdio.h>
main()
{
int n, d, p;
printf("n = ");
scanf("%d",&n);
d = 2;
while ( n > 1 ){
if ( n%d == 0 ) {
p = 0;
while( n%d ==0 ){
++p;
n = n/d;
}
printf(p>1?"%d^%d":"%d", d, p);
if ( n > 1 )
printf(" * ");
}
++d;
}
}
R. 0 sau 1

#include <stdio.h>
main()
{
int n, d, p;
printf("n = ");
14
scanf("%d",&n);
d = 2;
while ( n > 1 ){
if ( n%d == 0 ) {
p = 0;
while( n%d ==0 ){
++p;
n = n/d;
}
printf(p>1?"%d^%d":"%d", d, p);
if ( n > 1 )
printf(" * ");
}
++d;
}
}
R. afișează descompunerea în factori primi a unui număr natural n citit de la tastatură
52. Programul următor calculează cmmdc(n, m) pentru două numere naturale nenule n și m citite. Exemplu: n =
36, m = 30 => cmmdc(36, 30)= 6. Programul conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și
varianta ei corectă pentru ca programul să funcționeze corespunzător.
#include <stdio.h>
main()
{
int n, m;
printf("m = "); scanf("%d",&m);
while ( n != m )
if ( n < m )
n = n - m;
else
m = m - n;
printf("%d", n);
}
R. if ( n < m ) corect este if ( n > m )
#include <stdio.h>
main()
{
int n, m;
if ( n != m )
if ( n > m )
n = n - m;
else
m = m - n;
printf("%d", n);
}
R. if(n!=m) corect este while(n!=m)
#include <stdio.h>
main()
15
{
int n, m;
while ( n != 0 )
if ( n > m )
n = n - m;
else
m = m - n;
printf("%d", m);
}
R. while(n!=0) corect este while(n!=m)
36, m = 30 => cmmdc(36, 30)= 6. Completați punctele de suspensie cu caracterele corespunzătoare pentru ca
#include <stdio.h>
main()
{
int n, m;
.........
if ( n > m )
n = n - m;
else
m = m - n;
printf("%d", n);
}
R. while ( n != m )
36, m = 30 => cmmdc(36, 30)= 6. Completați punctele de suspensie cu caracterele corespunzătoare pentru ca
#include <stdio.h>
main()
{
int n, m;
while ( n != m )
if ( n > m )
.......
else
m = m - n;
printf("%d", n);
}
R. n = n - m;
57. Ce afișează programul următor dacă se citește de la tastatură 96 60 ?

#include <stdio.h>
main()
{
int n, m;
while ( n != m )
if ( n > m )
n = n - m;
else
16
m = m - n;
printf("%d", n);
}
R. 12

#include <stdio.h>
main()
{
int n, m;
while ( n != m )
if ( n > m )
n = n - m;
else
m = m - n;
printf("%d", n);
}
R. 1 și orice altceva

#include <stdio.h>
main()
{
int n, m;
while ( n != m )
if ( n > m )
n = n - m;
else
m = m - n;
printf("%d", n);
}
R. calculează cmmdc(n, m) pentru două numere naturale nenule n și m
36, m = 30 => 6. Programul conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și varianta ei
corectă pentru ca programul să funcționeze corespunzător.
#include <stdio.h>
main()
{
int n, m, r;
while ( n != 0 ){
r = n%m;
n = m;
m = r;
}
printf("%d", n);
}
R. while ( n != 0 ) corect este while ( m != 0 )
36, m = 30 => 6. Programul conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și varianta ei
17
#include <stdio.h>
main()
{
int n, m, r;
while ( m != 0 ){
r = n%m;
n = m;
m = r;
}
printf("%d", m);
}
R. printf("%d", m); corect este printf("%d", n);
36, m = 30 => 6. Completați punctele de suspensie cu caracterele corespunzătoare pentru ca programul să
funcționeze corect.
#include <stdio.h>
main()
{
int n, m, r;
while ( m != 0 ){
..............
n = m;
m = r;
}
printf("%d", n);
}
R. r = n%m;

#include <stdio.h>
main()
{
int n, m, r;
while ( m != 0 )
r = n%m, n = m, m = r;
printf("%d", n);
}
R. 12
64. Dacă pentru n se citește valoarea 4 ce valoare trebuie să citim pentru m astfel încât programul următor să
afișeze 1 ?
#include <stdio.h>
main()
{
int n, m, r;
while ( m != 0 )
r = n%m, n = m, m = r;
printf("%d", n);
}
R. 1 sau orice număr prim cu 4

18
#include <stdio.h>
main()
{
int n, m, r;
while ( m != 0 )
r = n%m, n = m, m = r;
printf("%d", n);
}
R. calculează cmmdc(n, m) pentru două numere naturale nenule n și m
66. Programul următor convertește numărul n dat, din baza 10 în baza b (2 <= b <= 9) dată. Exemple: 5(10) =
101(2); 10(10) = 12(8). Programul conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și varianta ei
#include <stdio.h>
main()
{
int n, b, nb = 0, z = 1, temp;
printf("b = "); scanf("%d",&b);
temp = n;
while ( temp != 0 ){
nb = nb + z * (temp%b);
temp = temp/10;
z = z * 10;
}
printf("%d convertit in baza %d = %d", n, b, nb);
}
R. temp = temp/10; corect este temp = temp/b;
#include <stdio.h>
main()
{
temp = n;
temp = temp/b;
z = z * b;
}
}
R. z = z * b; corect este z = z * 10;
#include <stdio.h>
main()
19
{
temp = n;
nb = nb + z * (temp%10);
temp = temp/b;
z = z * 10;
}
}
R. nb = nb + z * (temp%10); corect este nb = nb + z * (temp%b);
101(2); 10(10) = 12(8). Completați punctele de suspensie cu caracterele corespunzătoare pentru ca programul să
#include <stdio.h>
main()
{
temp = n;
temp = temp/b;
z = .............
}
}
R. z * 10;
#include <stdio.h>
main()
{
temp = n;
nb = ..... + z * (temp%b);
temp = temp/b;
z = z * 10;
}
}
R. nb
#include <stdio.h>
main()
{
20
temp = n;
temp = temp/.....;
z = z * 10;
}
}
R. b

#include <stdio.h>
main()
{
int n, m, x = 0, p = 1;
while ( n != 0 )
x = x + p * (n%m), n = n/m, p = p * 10;
printf("%d", x);
}
R. 1100
73. Dacă pentru n se citește valoarea 14 ce valoare trebuie să citim pentru m astfel încât programul următor să
afișeze 16 ?
#include <stdio.h>
main()
{
int n, m, x = 0, p = 1;
while ( n != 0 )
x = x + p * (n%m), n = n/m, p = p * 10;
printf("%d", x);
}
R. 8

#include <stdio.h>
main()
{
int n, m, x = 0, p = 1;
while ( n != 0 )
x = x + p * (n%m), n = n/m, p = p * 10;
printf("%d", x);
}
R. convertește numărul n, din baza 10 în baza m (2 <= m <= 9)
75. Programul calculează cmmmc(n, m) pentru două numere naturale nenule n şi m. Programul conține o
instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și varianta ei corectă pentru ca programul să funcționeze
corespunzător.
#include <stdio.h>
main()
21
{
int n, m, x, y, rest;

x = n;
y = m;
while ( y != 0 ){
rest = x%y;
x = y;
y = rest;
}
printf("cmmmc(%d, %d) = %d ", n, m, x / n * m );
}
R. printf("cmmmc(%d,%d)=%d",n,m,x/n*m); corect este printf("cmmmc(%d,%d)=%d",n,m,n*m/x);
76. Programul calculează cmmmc(n, m) pentru două numere naturale nenule n şi m. Completați punctele de
suspensie cu caracterele corespunzătoare pentru ca programul să funcționeze corect.
#include <stdio.h>
main()
{
int n, m, x, y, rest;

x = n;
y = m;
while ( y != 0 ){
rest = x%y;
x = y;
y = rest;
}
printf("cmmmc(%d, %d) = %d ", n, m, ......);
}
R. n * m / x

#include <stdio.h>
main()
{
int n, m, x, y;
y = n * m;
while ( m )
x = n%m, n = m, m = x;
printf("%d", y / n);
}
R. 175
78. Dacă pentru n se citește valoarea 12 ce valoare trebuie să citim pentru m astfel încât programul să afișeze 12
?
#include <stdio.h>
main()
{
int n, m, x, y;
y = n * m;
while ( m )
22
x = n%m, n = m, m = x;
printf("%d", y / n);
}
R. 12 sau 1
79. Programul următor citește o variabilă b (2 <= b <= 9) reprezentând o bază de numerație și un număr nb în
acea bază. El afișează numărul nb convertit în baza 10. Exemplu: nb = 177, b = 8 => n(10) = 127. Programul
#include <stdio.h>
main()
{
int n = 0, b, nb, z = 1;
printf("b = "); scanf("%d", &b);
printf("nb = "); scanf("%d", &nb);
while( nb ){
n = n + z * (nb%10);
nb = nb/b;
z = b * z;
}
printf("%d\n", n);
}
R. nb = nb/b; corect este nb = nb/10;
acea bază. El afișează numărul nb convertit în baza 10. Exemplu: nb = 177, b = 8 => n(10) = 127. Programul
#include <stdio.h>
main()
{
int n = 0, b, nb, z = 1;
while( nb ){
n = n + z * (nb%10);
nb = nb/10;
z = z * 10;
}
printf("%d\n", n);
}
R. z = z * 10; corect este z = z * b;
acea bază. El afișează numărul nb convertit în baza 10. Exemplu: nb = 177, b = 8 => n(10) = 127. Completați
punctele de suspensie cu caracterele corespunzătoare pentru ca programul să funcționeze corect.
#include <stdio.h>
main()
{
int n = 0, b, nb, z = 1;
while( nb ){
n = n + z * (nb%10);
nb = nb/10;
z =......;
}
printf("%d\n", n);
}
23
R. z * b
acea bază. El afișează numărul nb convertit în baza 10. Exemplu: nb = 177, b = 8 => n(10) = 127. Completați
punctele de suspensie cu caracterele corespunzătoare pentru ca programul să funcționeze corect.
#include <stdio.h>
main()
{
int n = 0, b, nb, z = 1;
while( nb ){
n = n + z * (nb%10);
nb = .....;
z = z * b;
}
printf("%d\n", n);
}
R. nb/10

#include <stdio.h>
main()
{
int n = 0, b, nb, z = 1;
while( nb )
n = n + z * (nb%10), nb = nb/10, z = z * b;
printf("%d\n", n);
}
R. 10
84. Dacă pentru b se citește valoarea 8 ce valoare trebuie să citim pentru nb astfel încât programul să afișeze 21
?
#include <stdio.h>
main()
{
int n = 0, b, nb, z = 1;
while( nb )
n = n + z * (nb%10), nb = nb/10, z = z * b;
printf("%d\n", n);
}
R. 25
85. Programul următor citește un număr n natural în baza 10 și afișează cifrele sale începând cu cifra cea mai
puțin semnificativă ale reprezentării sale într-o bază oarecare b (2 <= b <= 9). b se citește pe intrare.
Exemplu: n = 9301, b = 8 => 5 2 1 2 2. Programul conține o instrucțiune scrisă greșit. Scrieți instrucțiunea
greșită și varianta ei corectă pentru ca programul să funcționeze corespunzător.
#include <stdio.h>
main()
{
int n, b , c;
24
while( n ){
c = n % b;
printf("%d ",c);
n = n % b;
}
}
R. n = n % b; corect este n = n / b;
Exemplu: n = 9301, b = 8 => 5 2 1 2 2. Programul conține o instrucțiune scrisă greșit. Scrieți instrucțiunea
#include <stdio.h>
main()
{
int n, b , c;
while( n ){
c = n % 10;
printf("%d ",c);
n = n / b;
}
}
R. c = n % 10; corect este c = n % b;
Exemplu: n = 9301, b = 8 => 5 2 1 2 2. Completați punctele de suspensie cu caracterele corespunzătoare
pentru ca programul să funcționeze corect.
#include <stdio.h>
main()
{
int n, b , c;
while( n ){
c = n % b;
printf("%d ",c);
........
}
}
R. n = n / b;

#include <stdio.h>
main()
{
int n, b , c;
scanf("%d",&n);
scanf("%d",&b);
while( n ){
c = n % b;
printf("%d",c);
n = n / b;
}
}
25
R. 1111
89. Dacă pentru n se citește valoarea 12 ce valoare trebuie să citim pentru b astfel încât programul să afișeze 41
?
#include <stdio.h>
main()
{
int n, b , c;
scanf("%d",&n);
scanf("%d",&b);
while( n ){
c = n % b;
printf("%d",c);
n = n / b;
}
}
R. 8
puțin semnificativă ale reprezentării sale într-o bază oarecare b. b se citește pe intrare. Exemple: n = 9301, b =
8 => 5 2 1 2 2; n = 930, b = 16 => 2 A 3. Programul conține o instrucțiune scrisă greșit. Scrieți instrucțiunea
#include <stdio.h>
main()
{
int n, b, c;
while( n ){
c = n % 10;
printf(c < 10 ? "%d " : "%c ", c < 10 ? c : c + 55);
n = n / b;
}
}
8 => 5 2 1 2 2; n = 930, b = 16 => 2 A 3. Programul conține o instrucțiune scrisă greșit. Scrieți instrucțiunea
#include <stdio.h>
main()
{
int n, b, c;
while( n ){
c = n % b;
printf(c < 10 ? "%d " : "%c ", c < 10 ? c : c + 55);
n = n / 10;
}
}
R. n = n / 10; corect este n = n / b;
26
8 => 5 2 1 2 2; n = 930, b = 16 => 2 A 3. Completați punctele de suspensie cu caracterele corespunzătoare
#include <stdio.h>
main()
{
int n, b, c;
while( n ){
c = .... ;
printf(c < 10 ? "%d " : "%c ", c < 10 ? c : c + 55);
n = n / b;
}
}
R. n % b

#include <stdio.h>
main()
{
int n, b, c;
scanf("%d",&n);
scanf("%d",&b);
while( n ){
c = n % b;
printf(c < 10 ? "%d " : "%c ", c < 10 ? c : c + 55);
n = n / b;
}
}
R. D 5
94. Dacă pentru n se citește valoarea 23 ce valoare trebuie să citim pentru b astfel încât programul să afișeze 71
?
#include <stdio.h>
main()
{
int n, b, c;
scanf("%d",&n);
scanf("%d",&b);
while( n ){
c = n % b;
printf(c < 10 ? "%d" : "%c", c < 10 ? c : c + 55);
n = n / b;
}
}
R. 16
95. Dacă pentru b se citește valoarea 16 ce valoare trebuie să citim pentru n astfel încât programul să afișeze 12
?
#include <stdio.h>
main()
{
int n, b, c;
scanf("%d",&n);
scanf("%d",&b);
while( n ){
c = n % b;
printf(c < 10 ? "%d" : "%c", c < 10 ? c : c + 55);
n = n / b;
27
}
}
R. 33
puțin semnificativă ale reprezentării sale într-o bază oarecare b. b se citește pe intrare. Exemple: n = 022125, b
= 10 => 1039; n = 02655, b = 16 => DA5. Programul conține o instrucțiune scrisă greșit. Scrieți instrucțiunea
#include <stdio.h>
main()
{
int n, b, c;
printf("n = "); scanf("%o",&n);
while ( n ){
c = n % 10;
if ( c < 10 )
printf("%d", c);
else
printf("%c", c + 55);
n /= b;
}
}
#include <stdio.h>
main()
{
int n, b, c;
while ( n ){
c = n % b;
if ( c <= 10 )
printf("%d", c);
else
printf("%c", c + 55);
n /= b;
}
}
R. if( c <= 10 ) corect este if( c < 10 )
#include <stdio.h>
main()
{
int n, b, c;
while ( n ){
c = n % b;
if ( c < 10 )
printf("%d", c);
else
28
printf("%c", c + 55);
n /= 10;
}
}
R. n /= 10; corect este n /= b;
= 10 => 1039; n = 02655, b = 16 => DA5. Completați punctele de suspensie cu caracterele corespunzătoare
#include <stdio.h>
main()
{
int n, b, c;
while ( n ){
c = ... ;
if ( c < 10 )
printf("%d", c);
else
printf("%c", c + 55);
n /= b;
}
}
R. n % b
= 10 => 1039; n = 02655, b = 16 => DA5. Completați punctele de suspensie cu caracterele corespunzătoare
#include <stdio.h>
main()
{
int n, b, c;
while ( n ){
c = n % b;
if ( c < 10 )
printf("%d", c);
else
printf("%c", .....);
n /= b;
}
}
R. c + 55
101. Ce afișează programul următor dacă se citește de la tastatură 0725 16 (0765 16)?
#include <stdio.h>
main()
{
int n, b, c;
while ( n ){
c = n % b;
if ( c < 10 )
printf("%d", c);
else
29
printf("%c", c + 55);
n /= b;
}
}
R. 5D1 (5F1)
#include <stdio.h>
main()
{
int n, b, c;
while ( n ){
c = n % b;
if ( c < 10 )
printf("%d", c);
else
printf("%c", c + 55);
n /= b;
}
}
R. 16 (35)
#include <stdio.h>
main()
{
int n, b, c;
while ( n ){
c = n % b;
if ( c < 10 )
printf("%d", c);
else
printf("%c", c + 55);
n /= b;
}
}
R. 101111 (101011)
104. Dacă pentru b se citește valoarea 16 ce valoare trebuie să citim pentru n astfel încât programul să afișeze
F3 (D2) ?
#include <stdio.h>
main()
{
int n, b, c;
while ( n ){
c = n % b;
if ( c < 10 )
printf("%d", c);
else
printf("%c", c + 55);
n /= b;
}
}
30
R. 077 (055)
26 (44) ?
#include <stdio.h>
main()
{
int n, b, c;
while ( n ){
c = n % b;
if ( c < 10 )
printf("%d", c);
else
printf("%c", c + 55);
n /= b;
}
}
R. 076 (054)
1111 (0101) ?
#include <stdio.h>
main()
{
int n, b, c;
while ( n ){
c = n % b;
if ( c < 10 )
printf("%d", c);
else
printf("%c", c + 55);
n /= b;
}
}
R. 017 (012)
puțin semnificativă ale reprezentării sale într-o bază oarecare b. b se citește pe intrare. Exemple: n = 0x7F, b =
10 => 721; n = 0x7F, b = 8 => 771; n = 0xB, b = 2 => 1101. Programul conține o instrucțiune scrisă greșit.
Scrieți instrucțiunea greșită și varianta ei corectă pentru ca programul să funcționeze corespunzător.
#include <stdio.h>
main()
{
int n, b, c;
while ( n ){
c = n % b;
if ( c < 10 )
printf("%d", c);
else
printf("%c", c + 55);
n /= b;
}
}
31
R. scanf("%d",&n); corect era scanf("%x",&n);
10 => 721; n = 0x7F, b = 8 => 771; n = 0xB, b = 2 => 1101. Programul conține o instrucțiune scrisă greșit.
Scrieți instrucțiunea greșită și varianta ei corectă pentru ca programul să funcționeze corespunzător.
#include <stdio.h>
main()
{
int n, b, c;
printf("n = "); scanf("%x",&n);
while ( n ){
c = n % 16;
if ( c < 10 )
printf("%d", c);
else
printf("%c", c + 55);
n /= b;
}
}
R. c = n % 16; corect era c = n % b;
10 => 721; n = 0x7F, b = 8 => 771; n = 0xB, b = 2 => 1101. Completați punctele de suspensie cu caracterele
corespunzătoare pentru ca programul să funcționeze corect.
#include <stdio.h>
main()
{
int n, b, c;
printf("n = "); scanf("%....",&n);
while ( n ){
c = n % b;
if ( c < 10 )
printf("%d", c);
else
printf("%c", c + 55);
n /= b;
}
}
R. x
10 => 721; n = 0x7F, b = 8 => 771; n = 0xB, b = 2 => 1101. Completați punctele de suspensie cu caracterele
corespunzătoare pentru ca programul să funcționeze corect.
#include <stdio.h>
main()
{
int n, b, c;
while ( n ){
c = n % b;
if ( c < 10 )
printf("%d", c);
else
printf("%c", c + 55);
32
n /= ....;
}
}
R. b
111. Ce afișează programul următor dacă se citește de la tastatură 0x1A 10 (0x2B 10) (0x3A 8) (0x2C 8)
(0x1C 2) (0x1D 2) ?
#include <stdio.h>
main()
{
int n, b, c;
while ( n ){
c = n % b;
if ( c < 10 )
printf("%d", c);
else
printf("%c", c + 55);
n /= b;
}
}
R. 62 (34) (27) (45) (00111) (10111)
010111 (0101001)?
#include <stdio.h>
main()
{
int n, b, c;
while( n ){
c = n % b;
if( c < 10 )
printf("%d", c);
else
printf("%c", c + 55);
n /= b;
}
}
R. 0x3A (0x4A)
231 (63)?
#include <stdio.h>
main()
{
int n, b, c;
while( n ){
c = n % b;
if( c < 10 )
printf("%d", c);
else
printf("%c", c + 55);
n /= b;
}
}
33
R. 0x5A (0x1E)
221 (95)?
#include <stdio.h>
main()
{
int n, b, c;
while( n ){
c = n % b;
if( c < 10 )
printf("%d", c);
else
printf("%c", c + 55);
n /= b;
}
}
R. 0x7A (0x3B)
115. Program următor convertește un număr f fracționar din baza 10 într-o bază oarecare b (e.g. 2, 8, 16) cu
precizia prec. Programul conține o instrucțiune scrisă greșit. Exemplu: f = 0,123(10), b = 16, prec = 5 =>
0,1F7CE(16). Scrieți instrucțiunea greșită și varianta ei corectă pentru ca programul să funcționeze
corespunzător.
#include <stdio.h>
main()
{
int b, p, i = 0, prec;
float f, s;
printf("f = "); scanf("%d",&f);
printf("prec = "); scanf("%d",&prec);
while (i < prec) {
s = b * f;
p = (int)s;
f = s - p;
++i;
if ( p < 10)
printf("%d", p);
else
printf("%c", p + 55);
}
}
R. scanf("%d",&f); corect este scanf("%f",&f);
0,1F7CE(16). Scrieți instrucțiunea greșită și varianta ei corectă pentru ca programul să funcționeze
corespunzător.
#include <stdio.h>
main()
{
float f, s;
printf("f = "); scanf("%f",&f);
while (i < prec) {
34
s = b * f;
p = (int)s;
f = p - s;
++i;
if ( p < 10)
printf("%d", p);
else
printf("%c", p + 55);
}
}
R. f = p - s; corect este f = s - p;
0,1F7CE(16). Completați punctele de suspensie cu caracterele corespunzătoare pentru ca programul să
#include <stdio.h>
main()
{
float f, s;
while (i < prec) {
s = b * f;
p = (int)s;
f = s - .....;
++i;
if ( p < 10)
printf("%d", p);
else
printf("%c", p + 55);
}
}
R. p
0,1F7CE(16). Completați punctele de suspensie cu caracterele corespunzătoare pentru ca programul să
#include <stdio.h>
main()
{
float f, s;
while (i < prec) {
s = b * f;
p = (int)s;
f = s - p;
......
if ( p < 10)
printf("%d", p);
else
printf("%c", p + 55);
}
}
35
R. ++i;
119. Ce afișează programul următor dacă se citește de la tastatură 0.1 16 2 (0.2 16 2) (0.3 8 2) (0.1 8
2) (0.2 2 3) (0.9 2 2) ?
#include <stdio.h>
main()
{
float f, s;
while (i < prec) {
s = b * f;
p = (int)s;
f = s - p;
++i;
if ( p < 10)
printf("%d", p);
else
printf("%c", p + 55);
}
}
R. 19 (33) (23) (06) (001) (11)
120. Programul următor apelează o funcție care calculează diferența a două numere reale. Programul conține o
instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și varianta ei corectă pentru ca programul să funcționeze
corespunzător.
#include <stdio.h>
float scad(a, b);
main()
{
float x = 3.25, y = 4.05, dif;
dif = scad(x, y);
printf("%g - %g = %g\n", x, y, dif);
}
float scad(float a, float b)
{
float s;
s = a - b;
return s;
}
R. float scad(a, b); corect este float scad(float, float);
121. Completați punctele de suspensie cu caracterele corespunzătoare pentru ca programul să funcționeze

corect.
#include <stdio.h>
float scad(float, float);
main()
{
float x = 3.25, y = 4.05, dif;
dif = scad(x, y);
}
{
float s;
s = a - b;
............
}
36
R. return s;

corect.
#include <stdio.h>
main()
{
float x = 3.25, y = 4.05, dif;
dif = .....
}
{
float s;
s = a - b;
return s;
}
R. scad(x, y);

corect.
#include <stdio.h>
float scad(............);
main()
{
float x = 3.25, y = 4.05, dif;
dif = scad(x, y);
}
{
float s;
s = a - b;
return s;
}
R. float, float sau float a, float b

corect.
#include <stdio.h>
main()
{
float x = 3.25, y = 4.05, dif;
dif = scad(x, y);
}
float scad(...........)
{
float s;
s = a - b;
return s;
}
R. float a, float b
37
125. Programul următor trebuie să producă o afișare ca cea din imagine. Programul conține o instrucțiune scrisă
greșit. Scrieți instrucțiunea greșită și varianta ei corectă pentru ca programul să funcționeze corespunzător.
#include <stdio.h>
int main()
{
enum zile { LUN = 1, MAR = 1, MIE = 1, JOI, VIN, SAM, DUM, LUN };
printf("LUN=%d, MAR=%d, MIE=%d, JOI=%d \n", LUN, MAR, MIE, JOI);
return 0;
}
R. enum zile { LUN = 1, MAR = 1, MIE = 1, JOI, VIN, SAM, DUM, LUN }; corect este enum zile {
LUN = 1, MAR = 1, MIE = 1, JOI, VIN, SAM, DUM };
126. Programul următor trebuie să producă o afișare ca cea din imagine. Completați punctele de suspensie cu
caracterele corespunzătoare pentru ca programul să funcționeze corect.
#include <stdio.h>
int main()
{
enum zile { LUN = 1, MAR = 1, MIE = 1, JOI, VIN, SAM, DUM };
printf("LUN=%d, MAR=%d, MIE=%d, JOI=%d \n", .......);
return 0;
}
R. LUN, MAR, MIE, JOI
127. Ce afișează programul următor ?

#include <stdio.h>
int main()
{
enum zile { LUN = 1, MAR = 1, MIE = 1, JOI, VIN, SAM, DUM };
printf("LUN=%d, MAR=%d, MIE=%d, JOI=%d \n", LUN, MAR, MIE, JOI);
return 0;
}
R. LUN=1, MAR=1, MIE=1, JOI=2
128. Programul următor trebuie să producă o afișare ca cea din imagine. Programul conține o instrucțiune scrisă
greșit. Scrieți instrucțiunea greșită și varianta ei corectă pentru ca programul să funcționeze corespunzător.
#include <stdio.h>
int main()
{
enum zile { DUM = 1, LUN, MAR, MIE, JOI, VIN, SAM } zi;
enum zile ziua = DUM;
for ( zi = DUM; zi <= SAM; ++zi)

printf("numarul zilei = %d\n", zi);
printf("ziua = %d\n", zi);
return 0;
}
R. printf("ziua = %d\n", zi);corect este printf("ziua = %d\n", ziua);
129. Programul următor trebuie să producă o afișare ca cea din imagine. Completați punctele de suspensie cu
caracterele corespunzătoare pentru ca programul să funcționeze corect.
#include <stdio.h>
int main()
{
enum zile {...., LUN, MAR, MIE, JOI, VIN, SAM } zi;
for ( zi = DUM; zi <= SAM; ++zi)
38
printf("ziua = %d\n", ziua);
return 0;
}
R. DUM = 1

#include <stdio.h>
int main()
{
enum zile { DUM, LUN, MAR, MIE, JOI, VIN, SAM } zi;
for(zi = VIN; zi <= SAM; ++zi)
printf("ziua = %d\n", zi);
return 0;
}
R. numarul zilei = 5
numarul zilei = 6
ziua = 7

#include <stdio.h>
main()
{
printf("ziua = %d\n", ziua);
}
numarul zilei = 6
ziua = 0

#include <stdio.h>
main()
{
printf("numarul zilei = %d\n", ziua);
}
numarul zilei = 0

#include <stdio.h>
main()
{
enum zile { DUM, LUN, MAR, MIE, JOI = 5, VIN, SAM } zi;
}
numarul zilei = 7
39
ÎNTREBĂRI CURS 5: Declarații. Operatori. Controlul execuției programelor
1. Variabila reprezintă un obiect de date cu 4 caracteristici: numele, …., tipul de dată şi adresa de memorie.
a. atributul b. clasa de memorare c. valoarea d. intervalul de valori
2. Constanta reprezintă un obiect de date cu 4 caracteristici: numele, valoarea, ….. şi adresa de memorie.
a. clasa de memorare b. mulţimea de valori c. funcţia d. tipul de dată
3. Constanta reprezintă un obiect de date cu 4 caracteristici: numele, …., tipul de dată şi adresa de memorie.
a. atributul b. clasa de memorare c. valoarea d. intervalul de valori
4. Ce specifică un tip de dată?

a. clasa de memorare şi mulţimea de valori pe care le poate avea
b. mulţimea de valori pe care le poate avea şi ce operații pot fi executate pe această mulţime de valori
c. faptul că data este de intrare sau de ieşire
d. faptul că data este constantă sau variabilă
5. Un prefix …. la o constantă întreagă specifică scrierea în octal.

a. 0 (zero) b. o (litera mică o) c. O (litera mare O) d. 0x sau 0X
6. Valoarea unui întreg poate fi specificată în baza zece, în …. sau în hexazecimal.

a. baza 2 b. octal c. codul ASCII d. cod complement faţă de doi
7. Valoarea unui întreg poate fi specificată în baza zece, în octal sau în ….. .
a. baza 2 b. codul ASCII c. hexazecimal d. cod complement faţă de doi
8. Un prefix …. la o constantă întreagă specifică scrierea în hexazecimal.

a. x sau X b. H sau h c. F sau f d. 0x sau 0X
9. Numărul 31 din baza 10 poate fi scris în octal ca …..

a. 037 b. 031 c. 0x37 d. 0x31
10. Constantele în octal şi hexazecimal pot fi urmate de L şi U.

a. fals b. doar întregii în baza 10 pot fi urmaţi de L şi U
c. adevărat d. doar întregii în octal pot fi urmaţi de L şi U
11. 0XFUL
a. în baza 10 este valoarea 16 b. este o constantă de tipul float
c. este o construcţie eronată d. este o constantă de tipul unsigned long
12. În codul ASCII constanta '0' are valoarea 48, ….

a. care nu are nicio legătură cu valoarea numerică 0. b. care este tot una cu valoarea numerică 0
c. care este tot una cu ‘\0’ d. care este tot una cu constanta NULL
13. Construcţia #define VTAB '\013' este echivalentă cu:

a. este o construcţie greşită în C b. #define VTAB '\xb'
c. #define VTAB '\xd' d. #define VTAB '\0xb'
14. Constanta caracter '\0' reprezintă ….

a. ultima valoare din codul ASCII b. caracterul linie nouă
c. caracterul cu valoarea numerică zero d. valoarea 48
15. 'a' . . . . .
a. este acelaşi lucru cu "a" b. în codul ASCII are codul 97
c. este un tablou de caractere care conţine un litera a şi un '\0' d. în hexa are valoarea 10
40
16. De câte ori poate fi iniţializată o variabilă?
a. dacă variabila nu este automată, iniţializarea este făcută o singură dată cu o expresie variabilă
b. dacă variabila este automată, iniţializarea este făcută o singură dată cu o expresie variabilă
c. dacă variabila nu este automată, iniţializarea este făcută o singură dată cu o expresie constantă
d. dacă variabila este automată, iniţializarea este făcută o singură dată cu o expresie constantă
17. Variabilele automate pentru care nu există o iniţializare explicită …..

a. sunt iniţializate în faza de preprocesare b. sunt iniţializate la execuţie cu zero
c. sunt iniţializate implicit cu zero d. au valori nedefinite
18. Prin definiţie, valoarea numerică a unei expresii relaţionale sau logice este …. dacă expresia este adevărată
şi 0 dacă expresia este falsă.
a. 1 b. 0 c. diferită de zero d. nedefinită
19. Fie declaraţiile float x; int i; atunci atribuirile x = i; şi i = x;

a. implică doar în a doua atribuire efectuarea unei conversii
b. nu implică niciuna efectuarea vreunei conversii
c. implică amândouă efectuarea de conversii
d. implică doar în prima atribuire efectuarea unei conversii
20. Dacă n este 5, atunci x = n++ ; atribuie lui x valoarea …..

a. 6 b. 7 c. se semnalează eroare d. 5
21. Dacă n este 5, atunci x = ++n ; atribuie lui x valoarea …..

a. 6 b. 5 c. 7 d. se semnalează eroare
n = 5; n = 5;
22. Fie două seturi de câte două instrucţiuni: x = n++ ; x = ++n ;
În care set n devine 6 la final?
a. în primul b. în ambele c. în al doilea d. valoarea lui n este nedefinită în ambele seturi
23. Expresia (i+j)++

a. este corectă doar dacă i şi j sunt variabile b. este incorectă doar dacă i şi j sunt constante
c. este ilegală d. este corectă
if (c == '\n') { if (c == '\n')
24. Următoarele două secvenţe de cod sunt echivalente: s[i] = c; s[i++] = c;
++i;
a. doar dacă avem în ambele cazuri ++i sau i++ b. fals }
c. doar dacă avem în a doua secvenţă ++i d. adevărat
25. n = n & 0177;

a. pune pe zero toţi biţii lui n, afară de ultimii 7 biţi de ordin inferior
b. pune pe zero toţi biţii lui n
c. pune pe 1 toţi biţii lui n, afară de ultimii 7 biţi de ordin inferior
d. pune pe 0 ultimii 7 biţi de ordin inferior din n
26. x = x | SET_ON;
a. pune pe 0 în x biţii care au valoarea 0 în SET_ON
b. pune pe 1 în x biţii care au valoarea 1 în SET_ON
c. pune pe 0 în x biţii care au valoarea 1 în SET_ON
d. pune pe 1 în x biţii care au valoarea 0 în SET_ON
27. Controlul execuţiei programului (control flow) specifică …

a. modul cum se execută programul b. ordinea în care sunt efectuate calculele
c. lansarea în execuţie a programului sub controlul utilizatorului d. cele trei structuri de control
28. O expresie precum x = 0 devine o instrucţiune atunci când ….

41
a. se adaugă un egal: x = = 0 b. este plasată într-un program
c. este urmată de caracterul punct şi virgulă “;” d. este folosită la iniţializare
29. În C, caracterul punct şi virgulă “;” este ….

a. terminator de linie b. o instrucţiune c. un separator d. un terminator de instrucţiune
30. În loc de if(expresie != 0) se poate scrie ….

a. if(expresie) b. if(!expresie) c. if(expresie = = 0) d. if(expresie = = 1)
31. if (n > 0) În secvența de cod alăturată else se asociază cu ….

if (a > b)
z = a; a. nici unul din cei doi if pentru că se semnalează eroare
else b. if (a > b) c. if (n > 0)
z = b; d. if (a > b) dacă după z = a; nu s-ar fi pus ”;”
32. if (n > 0) În secvența de cod alăturată compilatorul …..

for (i = 0; i < n; i++)
if (s[i] > 0) { a. nu va ajunge niciodată să proceseze else
printf("ok");
return i; b. va semnala eroare
} c. va asocia else cu if (s[i] > 0)
else d. va asocia else cu if (n > 0)
printf("error\n");
33. Pentru ieşirea din switch se folosesc …..

a. doar instrucţiuni break b. doar instrucţiuni return.
c. ramurile case şi default d. instrucţiunile break sau return.
34. x = x & ~077

a. setează ultimii 7 biţi ai lui x la zero b. setează ultimii 7 biţi ai lui x la 1
c. setează ultimii 6 biţi ai lui x la zero d. setează ultimii 6 biţi ai lui x la 1
35. Variabila reprezintă un obiect de date cu 4 caracteristici: numele, valoarea, ….. şi adresa de memorie.
a. clasa de memorare b. mulţimea de valori c. funcţia d. tipul de dată
36. Numărul 31 din baza 10 poate fi scris în hexazecimal ca …..

a. x1F b. 0x1f c. 0x31 d. x31
37. Operatorul unar de negaţie ! converteşte un operand nenul în 0 şi un operand 0 în…..

a. 0 b. 1 c. într-o valoare nenulă d. într-o valoare diferită de 1
38. Programul următor afișează lungimea unui șir de caractere citit pe intrare.
Programul conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și
#include <stdio.h>
int strlen(char s[]);
main()
{
char s1[20], c;
int i = 0;
printf("\n Sirul : ");
while ( c = getchar() != '\n')
s1[i++] = c;
s1[i]='\0';
printf("\ns1 = \"%s\" are lungimea = %d\n", s1, strlen(s1));
return 0;
}
int strlen(char s[])
{
42
int i = 0;
while (s[i] != '\0')
++i;
return i;
}
R. while (c = getchar() != '\n') corect este while ((c = getchar()) != '\n')
varianta ei corectă pentru ca programul să producă afișarea din imagine.
#include <stdio.h>
main()
{
char s1[20], c;
int i = 0;
while ((c = getchar()) != '\n')
s1[i++] = c;
s1[i]='\0';
printf("\ns1 = "%s" are lungimea = %d\n", s1, strlen(s1));
return 0;
}
{
int i = 0;
while (s[i] != '\0')
++i;
return i;
}
R. printf("\ns1 = "%s" are lungimea = %d\n", s1, strlen(s1));

corect este printf("\ns1 = \"%s\" are lungimea = %d\n", s1, strlen(s1));
#include <stdio.h>
int strlen(char s);
main()
{
char s1[20], c;
int i = 0;
s1[i++] = c;
s1[i]='\0';
return 0;
}
int strlen(char s)
{
int i = 0;
while (s[i] != '\0')
++i;
return i;
}
R. int strlen(char s) corect este int strlen(char s[])
43
Completați punctele de suspensie cu instrucțiunea corespunzătoare pentru ca
#include <stdio.h>
main()
{
char s1[20], c;
int i = 0;
s1[i++] = c;
s1[i]='\0';
return 0;
}
{
int i = 0;
while (s[i] !=......)
++i;
return i;
}
R. '\0'
#include <stdio.h>
main()
{
char s1[20], c;
int i = 0;
s1[i++] = c;
s1[i]='\0';
return 0;
}
{
int i = 0;
while (s[i] != '\0')
.....
return i;
}
R. ++i;
#include <stdio.h>
main()
{
char s1[20], c;
44
int i = 0;
s1[i++] = c;
..............
return 0;
}
{
int i = 0;
while (s[i] != '\0')
++i;
return i;
}
R. s1[i]='\0';
#include <stdio.h>
main()
{
char s1[20], c;
int i = 0;
while ((c = ......) != '\n')
s1[i++] = c;
s1[i]='\0';
return 0;
}
{
int i = 0;
while (s[i] != '\0')
++i;
return i;
}
R. getchar()
#include <stdio.h>
main()
{
char s1[20], c;
int i = 0;
s1[.....] = c;
s1[i]='\0';
return 0;
}
{
45
int i = 0;
while (s[i] != '\0')
++i;
return i;
}
R. i++
46. Ce afișează programul următor dacă se citește de la tastatură sir.

#include <stdio.h>
int t(char s[]);
main()
{
char s1[20], c;
int i = 0;
s1[i++] = c;
s1[i]='\0';
printf("%d", t(s1));
return 0;
}
int t(char s[])
{
int i = 0;
while (s[i] != '\0')
++i;
return i;
}
R. 3
47. Ce trebuie să citim de la tastatură astfel încât programul să afișeze 3.

#include <stdio.h>
int t(char s[]);
main()
{
char s1[20], c;
int i = 0;
s1[i++] = c;
s1[i]='\0';
printf("%d", t(s1));
return 0;
}
int t(char s[])
{
int i = 0;
while (s[i] != '\0')
++i;
return i;
}
R. orice șir de 3 caractere
48. Precizați scopul funcției t() de mai jos?

int t(char s[])
{
int i = 0;
while (s[i] != '\0')
++i;
return i;
}
46
R. întoarce lungimea șirului s
49. Precizați scopul funcției r() de mai jos?

int r(char s[])
{
int i = -1;
while (s[++i] != '\0');
return i;
}
R. întoarce lungimea șirului s
50. Funcția următoare întoarce lungimea șirului s. Funcția conține o instrucțiune scrisă greșit. Scrieți
instrucțiunea greșită și varianta ei corectă.
{
int i;
while (s[i] != '\0')
++i;
return i;
}
R. int i; corect este int i = 0;
{
int i = 0;
while (s[i] != ”\0”)
++i;
return i;
}
R. ”\0” corect este '\0'
{
int i = 0;
while (s[++i] != '\0');
return i;
}
R. int i = 0; corect este int i = -1;
{
int i = 0;
while (s[i] != '\0');
++i;
return i;
}
R. while (s[i] != '\0'); corect este while (s[i] != '\0')

47
{
int i = -1;
while (s[++i] != '\0')
return i;
}
R. while (s[i] != '\0') corect este while (s[i] != '\0');
{
int i = -1;
while (s[i++] != '\0');
return i;
}
R. while (s[i++] != '\0'); corect este while (s[++i] != '\0');
56. Funcția următoare întoarce lungimea șirului s. Completați punctele de suspensie cu instrucțiunea
corespunzătoare pentru o funcție corectă.
{
int i = 0;
while (.......)
++i;
return i;
}
R. s[i] != '\0'
{
int i = 0;
while (s[i] != '\0')
......
return i;
}
R. ++i; sau i++;
{
int i = 0;
while (s[i] != '\0')
++i;
..........
}
R. return i;
48
59. Funcția următoare atoi(s) convertește un șir de cifre primit prin intermediul parametrului s - reprezentând
un număr natural - la echivalentul său numeric. Funcția conține o instrucțiune scrisă greșit. Scrieți instrucțiunea
greșită și varianta ei corectă.
int atoi(char s[])
{
int i, n = 0;
for (i = 0; s[i] >= '0' && s[i] <= '9'; ++i)
n = (s[i] - '0');
return n;
}
R. n = (s[i] - '0'); corect este n = 10 * n + (s[i] - '0');
int atoi(char s[])
{
int i, n = 0;
for (i = 0; s[i] >= '0' || s[i] <= '9'; ++i)
n = 10 * n + (s[i] - '0');
return n;
}
R. s[i] >= '0' || s[i] <= '9' corect este s[i] >= '0' && s[i] <= '9'
int atoi(char s[])
{
int i, n = 0;
for (i = 0; s[i] >= 0 && s[i] <= 9; ++i)
n = 10 * n + (s[i] - '0');
return n;
}
R. s[i] >= 0 && s[i] <= 9 corect este s[i] >= '0' && s[i] <= '9'
int atoi(char s[])
{
int i, n = 0;
for (i = 0; s[i] >= '0' && s[i] <= '9'; ++i)
n = n + (s[i] - '0');
return n;
}
R. n = n + (s[i] - '0'); corect este n = 10 * n + (s[i] - '0');
un număr natural - la echivalentul său numeric. Completați punctele de suspensie cu instrucțiunea
int atoi(char s[])
{
int i, n = 0;
49
for (i = 0; ....... ; ++i)
n = 10 * n + (s[i] - '0');
return n;
}
R. s[i] >= '0' && s[i] <= '9' sau isdigit(s[i])
64. Precizați scopul funcției f() de mai jos?

int f(char s[])
{
int i, n = 0;
for (i = 0; s[i] >= '0' && s[i] <= '9' ; ++i)
n = 10 * n + (s[i] - '0');
return n;
}
R. convertește caracterele cifră de la începutul șirului de caractere s la echivalentul lor numeric
65. Ce returnează funcția următoare la apelul f(”098”)?

int f(char s[])
{
int i, n = 0;
for (i = 0; s[i] >= '0' && s[i] <= '9' ; ++i)
n = 10 * n + (s[i] - '0');
return n;
}
R. 98
66. Ce returnează funcția următoare la apelul f(”abc098”)?

int f(char s[])
{
int i, n = 0;
for (i = 0; s[i] >= '0' && s[i] <= '9' ; ++i)
n = 10 * n + (s[i] - '0');
return n;
}
R. 0
67. Ce returnează funcția următoare la apelul f(”123abc98”)?

int f(char s[])
{
int i, n = 0;
for (i = 0; s[i] >= '0' && s[i] <= '9' ; ++i)
n = 10 * n + (s[i] - '0');
return n;
}
R. 123
68. Ce returnează funcția următoare la apelul f(”abc098”)?

int f(char s[])
{
int i = 0;
while (s[i] != '\0')
++i;
return i;
}
50
R. 6
69. Ce returnează funcția următoare la apelul f(”12ab”)?

int f(char s[])
{
int i = -1;
while (s[++i] != '\0');
return i;
}
R. 4
70. Ce returnează funcția următoare la apelul f(”012”)?

int f(char s[])
{
int i, n;
n = 0;
for (i = 0; isdigit(s[i]); ++i)
n = 10 * n + (s[i] - '0');
return n;
}
R. 12
71. Ce returnează funcția următoare la apelul f(”xyz25”)?

int f(char s[])
{
int i, n;
n = 0;
n = 10 * n + (s[i] - '0');
return n;
}
R. 0
72. Ce returnează funcția următoare la apelul f(”45xsw98”)?

int f(char s[])
{
int i, n;
n = 0;
n = 10 * n + (s[i] - '0');
return n;
}
R. 45

int f(char s[])
{
int i, n;
n = 0;
n = 10 * n + (s[i] - '0');
return n;
}
R. convertește caracterele cifră de la începutul șirului de caractere s la echivalentul lor numeric
51
74. Funcția următoare htoi(s), converteşte un şir de cifre hexazecimale (şirul putând include opţional un 0x
sau 0X) în valoarea întreagă echivalentă. Cifrele permise sunt: 0 până la 9, a până la f şi A până la F. Funcția
conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și varianta ei corectă.
unsigned long htoi(char s[])
{
unsigned long n = 0;
int c, i = 0;
if(s[0] == '0' || (s[1] == 'x' && s[1] == 'X'))
i = 2;
for (; s[i] != '\0'; ++i) {
c = s[i];
n *= 16;
if (c >= '0' && c <= '9')
n += c - '0';
else if (c >= 'a' && c <= 'f')
n += c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
n += c - 'A' + 10;
}
return n;
}
R. if(s[0] == '0' || (s[1] == 'x' && s[1] == 'X'))

corect este if(s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
{
int c, i = 0;
if(s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
i = 3;
for (; s[i] != '\0'; ++i) {
c = s[i];
n *= 16;
if (c >= '0' && c <= '9')
n += c - '0';
else if (c >= 'a' && c <= 'f')
n += c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
n += c - 'A' + 10;
}
return n;
}
R. i = 3; corect este i = 2;
{
int c, i = 0;
if(s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
i = 2;
for (; s[i] != '0'; ++i) {
c = s[i];
n *= 16;
if (c >= '0' && c <= '9')
n += c - '0';
52
else if (c >= 'a' && c <= 'f')
n += c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
n += c - 'A' + 10;
}
return n;
}
R. s[i] != '0' corect este s[i] != '\0'
{
int c, i = 0;
if(s[0] == '0' && s[1] == 'x' || s[1] == 'X')
i = 2;
for (; s[i]; ++i) {
c = s[i];
n *= 16;
if (c >= '0' && c <= '9')
n += c - '0';
else if (c >= 'a' && c <= 'f')
n += c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
n += c - 'A' + 10;
}
return n;
}
R. if(s[0] == '0' && s[1] == 'x' || s[1] == 'X')

corect este if(s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
sau 0X) în valoarea întreagă echivalentă. Cifrele permise sunt: 0 până la 9, a până la f şi A până la F.
Completați punctele de suspensie cu instrucțiunea corespunzătoare pentru o funcție corectă.
{
int c, i = 0;
if(s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
i = 2;
for (; s[i] != '\0'; ++i) {
c = s[i];
n *= 16;
if (........)
n += c - '0';
else if (c >= 'a' && c <= 'f')
n += c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
n += c - 'A' + 10;
}
return n;
}
R. c >= '0' && c <= '9' sau isdigit(c)
sau 0X) în valoarea întreagă echivalentă. Cifrele permise sunt: 0 până la 9, a până la f şi A până la F.
Completați punctele de suspensie cu instrucțiunea corespunzătoare pentru o funcție corectă.
53
{
int i = 0;
if ( s[0] == '0' && ( s[1] == 'x' || s[1] == 'X' ) )

i = 2;
for (; s[i]; ++i) {
n *= 16;
if (isdigit(s[i]))
n += .....;
else if (s[i] >= 'a' && s[i] <= 'f')
n += s[i] - 'a' + 10;
else if (s[i] >= 'A' && s[i] <= 'F')
n += s[i] - 'A' + 10;
}
return n;
}
R. s[i] - '0'
80. Precizați scopul funcției f() de mai jos.

unsigned long f(char s[])
{
int i = 0;
if ( s[0] == '0' && ( s[1] == 'x' || s[1] == 'X' ) )

i = 2;
for (; s[i]; ++i) {
n *= 16;
if (isdigit(s[i]))
n += s[i] - '0';
else if (s[i] >= 'a' && s[i] <= 'f')
n += s[i] - 'a' + 10;
else if (s[i] >= 'A' && s[i] <= 'F')
n += s[i] - 'A' + 10;
}
return n;
}
R. converteşte un şir de cifre hexazecimale (şirul putând include opţional un 0x sau 0X) în valoarea întreagă
echivalentă
81. Ce returnează funcția următoare la apelul f(”0X12”)?

{
int i = 0;
if ( s[0] == '0' && ( s[1] == 'x' || s[1] == 'X' ) )

i = 2;
for (; s[i]; ++i) {
n *= 16;
if (isdigit(s[i]))
n += s[i] - '0';
else if (s[i] >= 'a' && s[i] <= 'f')
n += s[i] - 'a' + 10;
else if (s[i] >= 'A' && s[i] <= 'F')
n += s[i] - 'A' + 10;
}
return n;
}
54
R. 18
82. Ce returnează funcția următoare la apelul f(”0X1n”)?

{
int i = 0;
if ( s[0] == '0' && ( s[1] == 'x' || s[1] == 'X' ) )

i = 2;
for (; s[i]; ++i) {
n *= 16;
if (isdigit(s[i]))
n += s[i] - '0';
else if (s[i] >= 'a' && s[i] <= 'f')
n += s[i] - 'a' + 10;
else if (s[i] >= 'A' && s[i] <= 'F')
n += s[i] - 'A' + 10;
}
return n;
}
R. 16
83. Cu ce valoare trebuie să apelăm funcția f() astfel încât aceasta să returneze 18 ?
{
int i = 0;
if ( s[0] == '0' && ( s[1] == 'x' || s[1] == 'X' ) )

i = 2;
for (; s[i]; ++i) {
if ( isdigit(s[i]) ){
n *= 16;
n += s[i] - '0';
}
else if (s[i] >= 'a' && s[i] <= 'f') {
n *= 16;
n += s[i] - 'a' + 10;
}
else if (s[i] >= 'A' && s[i] <= 'F') {
n *= 16;
n += s[i] - 'A' + 10;
}
}
return n;
}
R. 0x12 sau 0X12 sau 12 sau oricare dintre cele trei urmate de litere mai mari decât f sau F sau urmate de
alte caractere

int f(int c)
{
if (c >= 'A' && c <= 'Z')
return c + 'a' - 'A';
else
return c;
}
R. convertește un caracter majusculă la minusculă, lăsând minusculele și alte caractere nemodificate
55
85. Funcția următoare lower(), converteşte un caracter majusculă la minusculă, lăsând minusculele și alte
caractere nemodificate. Funcția conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și varianta ei
corectă.
int lower(int c)
{
if (c >= 'A' || c <= 'Z')
else
return c;
}
R. c >= 'A' || c <= 'Z' corect este c >= 'A' && c <= 'Z'
corectă.
int lower(int c)
{
if (c >= 'a' && c <= 'z')
else
return c;
}
R. c >= 'a' && c <= 'z' corect este c >= 'A' && c <= 'Z'
corectă.
int lower(int c)
{
if (c >= 'A' && c <= 'Z')
return c + 'A' - 'a';
else
return c;
}
R. c + 'A' - 'a' corect este c + 'a' - 'A'
88. Rescrieți funcția lower() de mai jos înlocuind instrucțiunea if cu operatorul condițional ? : .
int lower(int c)
{
if (c >= 'A' && c <= 'Z')
else
return c;
}
R. int lower(int c){ return c >= 'A' && c <= 'Z' ? c + 'a' - 'A' : c; }

int f(int c)
{
return c >= 'A' && c <= 'Z' ? c + 'a' - 'A' : c;
}
R. convertește un caracter majusculă la minusculă, lăsând minusculele și alte caractere nemodificate
56
caractere nemodificate. Funcția conține o secvență scrisă greșit. Scrieți secvența greșită și varianta ei corectă.
int lower(int c)
{
return c >= 'A' || c <= 'Z' ? c + 'a' - 'A' : c;
}
R. c >= 'A' || c <= 'Z' corect este c >= 'A' && c <= 'Z'
91. Funcția următoare f(), converteşte un caracter majusculă la minusculă, lăsând minusculele și alte caractere
nemodificate. Funcția conține o secvență scrisă greșit. Scrieți secvența greșită și varianta ei corectă.
int f(int c)
{
return c >= 'a' && c <= 'z' ? c + 'a' - 'A' : c;
}
R. c >= 'a' && c <= 'z' corect este c >= 'A' && c <= 'Z'
caractere nemodificate. Funcția conține o secvență scrisă greșit. Scrieți secvența greșită și varianta ei corectă.
int lower(int c)
{
return c >= 'A' && c <= 'Z' ? c + 'A' - 'a' : c;
}
R. c + 'A' - 'a' corect este c + 'a' - 'A'
caractere nemodificate. Completați punctele de suspensie cu instrucțiunea corespunzătoare pentru o funcție
corectă.
int lower(int c)
{
if (..........)
else
return c;
}
R. c >= 'A' && c <= 'Z'
corectă.
int lower(int c)
{
if (c >= 'A' && c <= 'Z')
return c +........;
else
return c;
}
R. 'a' - 'A'
corectă.
int lower(int c)
{
57
if (c >= 'A' && c <= 'Z')
else
............
}
R. return c;
corectă.
int lower(int c)
{
return ........... ? c + 'a' - 'A' : c;
}
R. c >= 'A' && c <= 'Z'
corectă.
int lower(int c)
{
return c >= 'A' && c <= 'Z' ? c + ......... : c;
}
R. 'a' - 'A'
corectă.
int lower(int c)
{
return c >= 'A' && c <= 'Z' ? c + 'a' - 'A' : ........;
}
R. c
99. Ce returnează funcția următoare la apelul f(”PoPe123ScU”)?

int f(int c)
{
return c >= 'A' && c <= 'Z' ? c + 'a' - 'A' : c;
}
R. pope123scu
int f(int c)
{
return c >= 'A' && c <= 'Z' ? c + 'a' - 'A' : c;
}
R. 18
101. Ce returnează funcția următoare la apelul f(”PoPe123ScU”)?

int f(int c)
{
if (c >= 'A' && c <= 'Z')
58
else
return c;
}
R. pope123scu
int f(int c)
{
if (c >= 'A' && c <= 'Z')
else
return c;
}
R. 108

void f(char s[], int c)
{
int i, j;
for (i = j = 0; s[i] != '\0'; i++)

if (s[i] != c)
s[j++] = s[i];
s[j] = '\0';
}
R. îndepărtează toate aparițiile caracterului c din șirul s
104. Funcția următoare squeeze(s, c), îndepărtează toate aparițiile caracterului c din șirul s. Funcția conține
o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și varianta ei corectă.
void squeeze(char s[], int c)
{
int i, j;
for (i = j = 0; s[i] != '\0'; i++)

if (s[i] != c)
s[j++] = s[i];
s[j] = '/0';
}
R. s[j] = '/0'; corect este s[j] = '\0';
{
int i, j;
for (i = j = 0; s[i] != '\0'; i++)

if (s[i] == c)
s[j++] = s[i];
s[j] = '\0';
}
R. if (s[i] == c) corect este if (s[i] != c)
59
{
int i, j;
for (i = j = 0; s[i] != '\0'; i++)

if (s[i] != c)
s[i++] = s[i];
s[j] = '\0';
}
R. s[i++] = s[i]; corect este s[j++] = s[i];
107. Funcția următoare squeeze(s, c), îndepărtează toate aparițiile caracterului c din șirul s. Completați
punctele de suspensie cu instrucțiunea corespunzătoare pentru o funcție corectă.
{
int i, j;
for (........; s[i] != '\0'; i++)

if (s[i] != c)
s[j++] = s[i];
s[j] = '\0';
}
R. i = j = 0
{
int i, j;
for (i = j = 0;.......; i++)

if (s[i] != c)
s[j++] = s[i];
s[j] = '\0';
}
R. s[i] != '\0' sau s[i]
{
int i, j;
for (i = j = 0; s[i] != '\0'; i++)

if (........)
s[j++] = s[i];
s[j] = '\0';
}
R. s[i] != c
{
int i, j;
for (i = j = 0; s[i] != '\0'; i++)
60
if (s[i] != c)
..........
s[j] = '\0';
}
R. s[j++] = s[i];
{
int i, j;
for (i = j = 0; s[i] != '\0'; i++)

if (s[i] != c)
s[j++] = s[i];
......
}
R. s[j] = '\0';
112. Ce returnează funcția următoare la apelul f(”popescu”, p)?

{
int i, j;
for (i = j = 0; s[i] != '\0'; i++)

if (s[i] != c)
s[j++] = s[i];
s[j] = '\0';
}
R. oescu
113. Dacă al doilea argument al funcției f() este ’i’, ce valoare trebuie să aibă primul argument pentru ca
apelul funcției f() să returneze om ?
{
int i, j;
for (i = j = 0; s[i] != '\0'; i++)

if (s[i] != c)
s[j++] = s[i];
s[j] = '\0';
}
R. i...ioi...imi...i unde i poate apare de fiecare dată de 0 sau mai multe ori

void f(char s[], char t[])
{
int i = 0, j = 0;
while (s[i] != '\0')
i++;
while ((s[i++] = t[j++]) != '\0');
}
R. concatenează șirul t la finalul șirului s
115. Funcția următoare strcat(s, t), concatenează șirul t la finalul șirului s. Funcția conține o instrucțiune
scrisă greșit. Scrieți instrucțiunea greșită și varianta ei corectă.
61
void strcat(char s[], char t[])
{
int i = 0, j = 0;
while (s[i] != '\0')
i++;
while ((s[i++] == t[j++]) != '\0');
}
R. (s[i++] == t[j++]) corect este (s[i++] = t[j++])
{
int i = 0, j = 0;
while (s[i] != '\0')
i++;
while ((s[i++] = t[i++]) != '\0');
}
R. (s[i++] = t[i++]) corect este (s[i++] = t[j++])
{
int i = 0, j = 0;
while (s[i] != '\0')
i++;
while ((s[i] = t[j]) != '\0');
}
R. (s[i] = t[j]) corect este (s[i++] = t[j++])
{
int i = 0, j = 0;
while (s[i] != '\0')
j++;
while ((s[i++] = t[j++]) != '\0');
}
R. j++; corect este i++;
119. Funcția următoare strcat(s, t), concatenează șirul t la finalul șirului s. Completați punctele de
suspensie cu instrucțiunea corespunzătoare pentru o funcție corectă.
{
int i = 0, j = 0;
while (s[i] != '\0')
.....
while ((s[i++] = t[j++]) != '\0');
}
R. i++;
120. Funcția următoare strcat(s, t), concatenează șirul t la finalul șirului s. Completați punctele de
suspensie cu secvența corespunzătoare pentru o funcție corectă.
62
{
int i = 0, j = 0;
while (s[i] != '\0')
i++;
while ((s[i++] =......) != '\0');
}
R. t[j++]
121. Ce returnează funcția următoare la apelul f(”popescu”, ”p”)?

{
int i = 0, j = 0;
while (s[i] != '\0')
i++;
while ((s[i++] = t[j++]) != '\0');
}
R. popescup
122. Dacă al doilea argument al funcției f() este ”r”, ce valoare trebuie să aibă primul argument pentru ca
apelul funcției f() să returneze programator ?
{
int i = 0, j = 0;
while (s[i] != '\0')
i++;
while ((s[i++] = t[j++]) != '\0');
}
R. programato
123. Ce returnează funcția următoare la apelul f(077, 4, 3)?

unsigned f(unsigned x, int p, int n)
{
return (x >> (p + 1 - n)) & ~(~0 << n);
}
R. 7

{
return (x >> (p + 1 - n)) & ~(~0 << n);
}
R. 4

{
return (x >> (p + 1 - n)) & ~(~0 << n);
}
R. 3
126. Ce returnează funcția următoare la apelul f(170, 5)?

unsigned f(unsigned n, int b)
{
return (n & ~(1 << b));
63
}
R. 138

{
return (n & ~(1 << b));
}
R. 134

{
return (n & ~(1 << b));
}
R. 97

{
return (n & ~(1 << b));
}
R. 74
130. Valoarea returnată de funcția f() următoare este obținută cu o transformare asupra biților numărului întreg
fără semn n. Care este această transformare?
{
return (n & ~(1 << b));
}
R. setează bitul b din numărul întreg n la 0
131. Ce face programul următor?

#include <stdio.h>
unsigned f(unsigned n, int b);
int main()
{
unsigned n = 170;
int b = 5;
for( b = 15; b >=0; --b )
printf("%d ", f(n, b) );
return 0;
}

{
if( n & 1 << b )
return 1;
else
return 0;
}
R. afișează ultimii 16 biți ai lui n separați prin spațiu: 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0
64
132. Ce face programul următor?
#include <stdio.h>
int main()
{
unsigned n = 170;
int b;
for( b = 15; b >=0; --b )
return 0;
}

{
return n & 1 << b ? 1 : 0;
}
R. afișează ultimii 16 biți ai lui n separați prin spațiu: 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0
133. Ce rol are funcția f() următoare?

{
return n & 1 << b ? 1 : 0;
}
R. determină valoarea bitului b din numărul întreg fără semn n

{
if( n & 1 << b )
return 1;
else
return 0;
}
R. determină valoarea bitului b din numărul întreg fără semn n

{
if( n & 1 << b )
return 1;
else
return 0;
}
R. 1

{
return n & 1 << b ? 1 : 0;
}
R. 0

{
65
if( n & 1 << b )
return 1;
else
return 0;
}
R. 1

{
return n & 1 << b ? 1 : 0;
}
R. 0
139. Înlocuiți punctele de suspensie cu secvența de cod corespunzătoare astfel încât funcția f() de mai jos să
determine valoarea bitului b din numărul întreg fără semn n.
{
return n ... 1 << b ? 1 : 0;
}
R. &
determine valoarea bitului b din numărul întreg fără semn n.
{
if( n ... 1 << b )
return 1;
else
return 0;
}
R. &
141. Funcția f() de mai jos determină valoarea bitului b din numărul întreg fără semn n. Funcția conține o
greșeală. Scrieți greșeala și varianta ei corectă pentru ca funcția să lucreze corespunzător.
{
return n & 1 >> b ? 1 : 0;
}
R. 1 >> b corect este 1 << b
{
if( n & 1 >> b )
return 1;
else
return 0;
}
R. 1 >> b corect este 1 << b
66
{
return n | 1 << b ? 1 : 0;
}
R. n | 1 << b corect este n & 1 << b
{
if( n | 1 << b )
return 1;
else
return 0;
}
R. n | 1 << b corect este n & 1 << b
145. Ce afișează programul următor?

#include <stdio.h>
int main()
{
unsigned n = 170;
int b = 2;
return 0;
}

{
return (n | 1 << b);
}
R. 174

{
}
R. 174

{
}
R. 21

{
67
}
R. 29

{
}
R. 30
seteze bitul b din numărul întreg fără semn n la 1.
{
return (n .... 1 << b);
}
R. |
seteze bitul b din numărul întreg fără semn n la 1.
{
return (n | 1 .... b);
}
R. <<
152. Funcția f() de mai jos setează bitul b din numărul întreg fără semn n la 1. Funcția conține o greșeală.
Scrieți greșeala și varianta ei corectă pentru ca funcția să lucreze corespunzător.
{
return (n & 1 << b);
}
R. (n & 1 << b) corect este (n | 1 << b)
153. Funcția f() de mai jos setează bitul b din numărul întreg fără semn n la 1. Funcția conține o greșeală.
Scrieți greșeala și varianta ei corectă pentru ca funcția să lucreze corespunzător.
{
return (n | 1 >> b);
}
R. (n | 1 >> b) corect este (n | 1 << b)

{
}
R. setează bitul b din numărul întreg fără semn n la 1
68
#include <stdio.h>
int main()
{
unsigned n = 127;
printf("%d ", f(n, 6) );
return 0;
}
{
return n % (1 << b);
}
R. 63

#include <stdio.h>
int main()
{
unsigned n = 27;
printf("%d ", f(n, 2) );
return 0;
}
{
return n & ( (1 << b) - 1 );
}
R. 3

{
}
R. 1

{
}
R. 1

{
}
R. 5

{
}
69
R. 9

{
return n & ( (1 << b) - 1 );
}
R. 6

{
return n & ( (1 << b) - 1 );
}
R. 2

{
return n & ( (1 << b) - 1 );
}
R. 15

{
return n & ( (1 << b) - 1 );
}
R. 13
întoarcă valoarea ultimilor b biți din reprezentarea internă a unui număr întreg n.
{
return n % (1 ...... b);
}
R. <<
{
return n ..... (1 << b);
}
R. %
{
70
return n & ( (1 ...... b) - 1 );
}
R. <<
{
return n ..... ( (1 << b) - 1 );
}
R. &
169. Funcția f() de mai jos întoarce valoarea ultimilor b biți din reprezentarea internă a unui număr întreg n.
Funcția conține o greșeală. Scrieți greșeala și varianta ei corectă pentru ca funcția să lucreze corespunzător.
{
return n % (1 >> b);
}
R. n % (1 >> b) corect este n % (1 << b)
{
return n / (1 << b);
}
R. n / (1 << b) corect este n % (1 << b)
{
return n & ( (1 >> b) - 1 );
}
R. (1 >> b) - 1 corect este (1 << b) - 1
{
return n && ( (1 << b) - 1 );
}
R. n && ( (1 << b) - 1 ) corect este n & ( (1 << b) - 1 )

{
return n & ( (1 << b) - 1 );
}
R. întoarce valoarea ultimilor b biți din reprezentarea internă a unui număr întreg n
71
{
}
R. întoarce valoarea ultimilor b biți din reprezentarea internă a unui număr întreg n

{
return x & ~(~(~0U << n) << (p + 1 - n));
}
R. începînd din poziția p transformă în 0 n biți din x, iar ceilalți biți îi lasă nemodificați

{
return x & ~(~(~0U << n) << (p + 1 - n));
}
R. 143

{
return x & ~(~(~0U << n) << (p + 1 - n));
}
R. 195

{
return x & ~(~(~0U << n) << (p + 1 - n));
}
R. 135

{
return x & ~(~(~0U << n) << (p + 1 - n));
}
R. 3

{
unsigned mask = ~(~0U << n) << (p + 1 - n);
return x ^ mask;
}
R. returnează pe x cu cei n biţi care încep la poziţia p inversaţi (i.e. 1 schimbat în 0 şi 0 în 1), lăsând
ceilalţi biţi nemodificaţi
72
{
return x ^ mask;
}
R. 11

{
return x ^ mask;
}
R. 143

{
return x ^ mask;
}
R. 183

{
return x ^ mask;
}
R. 19

int f(unsigned x)
{
int b;
for (b = 0; x != 0; x >>= 1)
if (x & 01)
b++;
return b;
}
R. contorizează numărul de biţi 1 din întregul fără semn furnizat ca argument
186. Ce returnează funcția următoare la apelul f(43)?

int f(unsigned x)
{
int b;
for (b = 0; x != 0; x >>= 1)
if (x & 01)
b++;
return b;
}
73
R. 4

int f(unsigned x)
{
int b;
for (b = 0; x != 0; x >>= 1)
if (x & 01)
b++;
return b;
}
R. 8

int f(unsigned x)
{
int b;
for (b = 0; x != 0; x >>= 1)
if (x & 01)
b++;
return b;
}
R. 3

int f(unsigned x)
{
int b;
for (b = 0; x != 0; x >>= 1)
if (x & 01)
b++;
return b;
}
R. 6

int f(unsigned x)
{
int b;
for (b = 0; x != 0; x &= (x - 1))
b++;
return b;
}
R. contorizează numărul de biţi 1 din întregul fără semn furnizat ca argument

int f(unsigned x)
{
int b;
for (b = 0; x != 0; x &= (x - 1))
b++;
return b;
}
R. 3
74
int f(unsigned x)
{
int b;
for (b = 0; x != 0; x &= (x - 1))
b++;
return b;
}
R. 4

int f(unsigned x)
{
int b;
for (b = 0; x != 0; x &= (x - 1))
b++;
return b;
}
R. 6

int f(unsigned x)
{
int b;
for (b = 0; x != 0; x &= (x - 1))
b++;
return b;
}
R. 4
195. Funcția următoare de căutare binară decide dacă o valoare particulară x apare în tabloul sortat crescător
v[], ea returnează poziția în care se află valoarea x, sau -1 dacă valoarea nu apare în v[]. Funcția conține o
instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și varianta ei corectă pentru ca funcția să lucreze
corespunzător.
int binsearch(int x, int v[], int n)
{
int low, high, mid;
low = 0;
high = n - 1;
while ( low <= high ) {
mid = (low + high)/2;
if (x < v[mid])
high = mid + 1;
else if (x > v[mid])
low = mid + 1;
else
return mid;
}
return -1;
}
R. high = mid + 1;corect este high = mid - 1;
corespunzător.
75
{
int low, high, mid;
low = 0;
high = n - 1;
if (x < v[mid])
high = mid - 1;
low = mid - 1;
else
return mid;
}
return -1;
}
R. low = mid - 1; corect este low = mid + 1;
corespunzător.
{
int low, high, mid;
low = 0;
high = n - 1;
if (x > v[mid])
high = mid - 1;
low = mid + 1;
else
return mid;
}
return -1;
}
R. if (x > v[mid]) high = mid - 1; corect este if (x < v[mid]) high = mid - 1;
corespunzător.
{
int low, high, mid;
low = 0;
high = n - 1;
if (x < v[mid])
high = mid - 1;
else if (x == v[mid])
low = mid + 1;
else
return mid;
}
return -1;
}
R. else if (x == v[mid]) corect este else if (x > v[mid])
76
v[], ea returnează poziția în care se află valoarea x, sau -1 dacă valoarea nu apare în v[]. Completați punctele
de suspensie cu secvența de cod corespunzătoare pentru ca funcția să lucreze corect.
{
int low, high, mid;
low = 0;
high = n - 1;
mid = .....;
if (x < v[mid])
high = mid - 1;
low = mid + 1;
else
return mid;
}
return -1;
}
R. (low + high)/2
{
int low, high, mid;
low = 0;
high = n - 1;
while (low <= high) {
mid = ( low + high )/2;
if (x < v[mid])
high = ....;
low = mid + 1;
else
return mid;
}
return -1;
}
R. mid - 1
{
int low, high, mid;
low = 0;
high = n - 1;
while (low <= high) {
mid = ( low + high )/2;
if (x < v[mid])
high = mid - 1;
low = .......;
else
return mid;
}
return -1;
}
R. mid + 1
77
{
int low, high, mid;
low = 0;
high = n - 1;
if (x < v[mid])
high = mid - 1;
else if ( .... )
low = mid + 1;
else
return mid;
}
return -1;
}
R. x > v[mid]
{
int low, high, mid;
low = 0;
high = n - 1;
if ( .... )
high = mid - 1;
else if ( x > v[mid] )
low = mid + 1;
else
return mid;
}
return -1;
}
R. x < v[mid]
{
int low, high, mid;
low = 0;
high = n - 1;
while ( .... ) {
if ( x < v[mid] )
high = mid - 1;
else if ( x > v[mid] )
low = mid + 1;
else
return mid;
}
return -1;
}
78
R. low <= high
205. Avem declarațiile int x = 12, n = 10, v[10] = {2, 3, 7, 10, 11, 12, 15, 18, 20, 21}; Ce
returnează funcția următoare la apelul f(x, v, n)?
int f(int x, int v[], int n)
{
int l = 0, h, m;
high = n - 1;
while ( l <= h ) {
m = (l + h)/2;
if ( x < v[m] )
h = m - 1;
else if ( x > v[m] )
l = m + 1;
else
return m;
}
return -1;
}
R. 5
206. Avem declarațiile int x = 12, n = 10, v[10] = {2, 3, 7, 10, 11, 13, 15, 18, 20, 21}; Ce
returnează funcția următoare la apelul f(x, v, n)?
{
int l = 0, h, m;
high = n - 1;
while ( l <= h ) {
m = (l + h)/2;
if ( x < v[m] )
h = m - 1;
l = m + 1;
else
return m;
}
return -1;
}
R. -1
207. Dacă int n = 10, v[10] = {2, 3, 7, 10, 11, 12, 15, 18, 20, 21}; Cât trebuie să fie valoarea
lui x astfel încât funcția să returneze 5?
{
int l = 0, h, m;
high = n - 1;
while ( l <= h ) {
m = (l + h)/2;
if ( x < v[m] )
h = m - 1;
l = m + 1;
else
return m;
}
return -1;
}
R. 12
79
208. Dacă int n = 10, v[10] = {2, 3, 7, 10, 11, 12, 15, 18, 20, 21}; Cât trebuie să fie valoarea
lui x astfel încât funcția să returneze -1?
{
int l = 0, h, m;
high = n - 1;
while ( l <= h ) {
m = (l + h)/2;
if ( x < v[m] )
h = m - 1;
l = m + 1;
else
return m;
}
return -1;
}
R. orice număr natural diferit de 2, 3, 7, 10, 11, 12, 15, 18, 20, 21
209. Dacă int n = 5, v[5] = {3, 7, 10, 15, 21}; Cât trebuie să fie valoarea lui x astfel încât funcția să
returneze 4?
{
int l = 0, h, m;
high = n - 1;
while ( l <= h ) {
m = (l + h)/2;
if ( x < v[m] )
h = m - 1;
l = m + 1;
else
return m;
}
return -1;
}
R. 21
210. Dacă int n = 5, v[5] = {3, 7, 10, 15, 21}; Cât trebuie să fie valoarea lui x astfel încât funcția să
returneze -1?
{
int l = 0, h, m;
high = n - 1;
while ( l <= h ) {
m = (l + h)/2;
if ( x < v[m] )
h = m - 1;
l = m + 1;
else
return m;
}
return -1;
}
R. orice număr natural diferit de 3, 7, 10, 15, 21
80
211. Precizați scopul funcției de mai jos?
int f(int v, int x[], int n)
{
int s = 0, d, c;
d = n - 1;
while ( s <= d) {
c = ( s + d )/2;
if ( v < x[c] )
d = c - 1;
else if ( v > x[c] )
s = c + 1;
else
return c;
}
return -1;
}
R. Funcția f() de căutare binară decide dacă o valoare particulară v apare în tabloul sortat crescător x[], f()
returnează poziția în care se află valoarea v, sau -1 dacă valoarea nu apare în x[]
212. Precizați ce face funcția f()de mai jos?

{
int i, j;
for (i = 0, j = 0; t[i] != '\0'; ++i) {
switch (t[i]) {
case '\n':
s[j++] = '\\';
s[j++] = 'n';
break;
case '\t':
s[j++] = '\\';
s[j++] = 't';
break;
default:
s[j++] = t[i];
break;
}
}
s[j] = '\0';
}
R. Funcția f()converteşte caracterele newline şi tab din șirul de caractere t[] în secvențe escape ”vizibile”:
\n şi \t, celelalte caractere le lasă nemodificate; rezultatul conversiei îl plasează în șirul de caractere s[].
213. Funcția următoare converteşte caracterele newline şi tab din șirul de caractere t[] în secvențe escape
”vizibile”: \n şi \t, celelalte caractere le lasă nemodificate; rezultatul conversiei îl plasează în șirul de
caractere s[]. Funcția conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și varianta ei corectă
pentru ca funcția să se comporte corespunzător.
void escape(char s[], char t[])
{
int i = 0, j = 0;
for (; t[i] != '\0'; ++i) {
switch (t[i]) {
case '\n':
s[j++] = '\';
s[j++] = 'n';
break;
case '\t':
s[j++] = '\';
s[j++] = 't';
break;
default:
81
s[j++] = t[i];
break;
}
}
s[j] = '\0';
}
R. s[j++] = '\'; corect este s[j++] = '\\';
214. Funcția următoare unescape() convertește secvenţele escape ”vizibile”: \n şi \t din șirul de caractere
t[] în caracterele newline şi tab, celelalte caractere le lasă nemodificate și plasează șirul convertit în s[]. De
exemplu dacă afișarea lui t[] este a\tx\nb\tx\nc\tx\n adică a <tab> x <enter> b <tab> x <enter> c
<tab> x <enter> se obține o afișare pe trei linii: pe prima linie caracterul a separat prin caracterul <tab> de x,
pe a doua linie caracterul b separat prin caracterul <tab> de x, iar pe ultima linie caracterul c separat prin
caracterul <tab> de x (vezi imaginea). Funcția conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită
și varianta ei corectă pentru pentru ca funcția să se comporte corespunzător.
void unescape(char s[], char t[])
{
int i = 0, j = 0;
for (; t[i] != '\0'; ++i) {
if (t[i] == '\') {
switch (t[++i]) {
case 'n':
s[j++] = '\n';
break;
case 't':
s[j++] = '\t';
break;
case '\0':
default:
s[j++] = '\\';
--i;
break;
}
} else
s[j++] = t[i];
}
s[j] = '\0';
}
R. if (t[i] == '\') corect este if (t[i] == '\\')
82
ÎNTREBĂRI CURS 6: Controlul execuției programelor. Funcții. Stiva
1. Se consideră o stivă în care iniţial au fost introduse, în această ordine, elementele cu valorile 1, 2 şi 3. Se
notează cu AD(x) operaţia prin care se adaugă elementul cu valoarea x în vârful stivei şi cu EL operaţia prin care
se elimină elementul din vârful stivei. Asupra acestei stive se execută următoarea secvenţă de operaţii: AD(4);
EL; AD(5); EL; AD(6); EL; EL. Care este valoarea elementului din vârful stivei în urma
executării acestei secvenţe de operaţii?
a. 2 b. 1 c. 5 d. 3
2. Se consideră o stivă în care iniţial au fost introduse, în această ordine, elementele cu valorile 1, 2 şi 3. Se
notează cu AD(x) operaţia prin care se adaugă elementul cu valoarea x în vârful stivei şi cu EL operaţia prin care
se elimină elementul din vârful stivei. Asupra acestei stive se execută următoarea secvenţă de operaţii: AD(4);
EL; AD(5); EL; AD(6); EL; EL. Care este suma valorilor elementelor aflate în stivă în urma
executării acestei secvenţe de operaţii?
a. 11 b. 3 c. 9 d. 15
3. În while(expresie)instrucţiune repetarea executării instrucţiunii se reia până când ….

a. expresia devine zero b. expresia devine 1 c. expresia devine nenulă d. instrucţiunea devine 0
4. for (expresie1; expresie2; expresie3) instrucţiune este echivalentă cu:

expresie1; while (expresie2){ while (expresie2){ expresie1;
while (expresie2){ a. expresie1; b. expresie1; c. while (expresie2){
instrucţiune d. instrucţiune expresie3; expresie3;
expresie3; expresie3; instrucţiune instrucţiune
} } } }
5. Cât este valoarea lui i la ieşirea din ciclul for de mai jos?
for (i = 0; i < 10; i++)
printf(”i=%d\n”,i);
a. 9 b. 10 c. 11 d. niciuna din cele trei a., b., c.
6. Un for ca cel de mai jos:

for (;;) {...}
a. este semnalat ca eroare de compilator b. este un ciclul cu număr cunoscut de paşi
c. este un ciclu „infinit” d. nu este un ciclu
7. Contorul şi limita unui ciclu for în C ….

a. nu pot fi modificate din interiorul ciclului b. se iniţializează la fiecare reluare a ciclului for
c. sunt interschimbabile d. pot fi modificate din interiorul ciclului
8. La ieşirea din ciclul for variabila contor …

a. îşi păstrează valoarea b. nu îşi păstrează valoarea c. are o valoare nedefinită d. are valoarea 0
9. Operatorul virgulă ….
a. nu există în C b. nu se utilizează niciodată în instrucţiunea for
c. se evaluează de la dreapta la stânga d. se evaluează de la stânga la dreapta
83
10. Funcţia void f(char s[])
{ a. inversează şirul de caractere s în el însuşi
int c, i, j; b. conţine o eroare în instrucţiunea for
for(i=0,j=strlen(s)-1; i<j; i++,j--) c. conţine două erori în instrucţiunea for
c = s[i], s[i] = s[j], s[j] = c;
} d. foloseşte greşit interschimbarea
11. Într-un apel de forma: getline(line, MAXLINE);

a. între line şi MAXLINE este operatorul virgulă ”,” b. între line şi MAXLINE nu este operatorul virgulă ”,”
c. evaluarea se face de la stânga la dreapta d. evaluarea se face de la dreapta la stânga
12. Un break în interiorul unui switch aflat în interiorul unui ciclu

a. produce ieşirea din switch şi din ciclu b. determină reluarea ciclului de la început
c. produce ieşirea din switch d. produce ieşirea din ciclu
13. Un break în interiorul unui ciclu aflat în interiorul unui switch

a. produce ieşirea din ciclu şi apoi din switch b. produce ieşirea din switch
c. produce ieşirea din switch şi din ciclu d. produce ieşirea din ciclu
14. Instrucțiunea continue

a. în cazul lui for, trece controlul la pasul de incrementare b. nu se foloseşte niciodată în cicluri
c. determină continuarea iterației ciclului care o conţine. d. în cazul lui while şi do sare partea de test
15. Precizați scopul funcției f() de mai jos.

int f(char s[])
{
int i, n, m;
for (i = 0; isspace(s[i]); i++);
m = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
for (n = 0; isdigit(s[i]); i++)
n = 10 * n + (s[i] - '0');
return m * n;
}
R. convertește un șir de caractere s[] la echivalentul său numeric; s[] poate fi prefixat de spații albe și poate
prezenta semnul + sau -.
16. Funcția următoare convertește un șir de caractere s[] la echivalentul său numeric; s[] poate fi prefixat de
spații albe și poate prezenta semnul + sau -. Funcția conține o instrucțiune scrisă greșit. Scrieți instrucțiunea
int atoi(char s[])
{
int i, n, sign;
for (i = 0; isspace(s[i]); i++)
sign = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return sign * n;
}
84
R. for (i = 0; isspace(s[i]); i++) corect este for (i = 0; isspace(s[i]); i++);
int atoi(char s[])
{
int i, n, sign;
sign = (s[i] == '-') ? 1 : -1;
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return sign * n;
}
R. sign = (s[i] == '-') ? 1 : -1; corect este sign = (s[i] == '-') ? -1 : 1;
int atoi(char s[])
{
int i, n, sign;
sign = (s[i] = '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return sign * n;
}
R. sign = (s[i] = '-') ? -1 : 1; corect este sign = (s[i] == '-') ? -1 : 1;
int atoi(char s[])
{
int i, n, sign;
sign = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' && s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return sign * n;
}
R. if (s[i] == '+' && s[i] == '-') corect este if (s[i] == '+' || s[i] == '-')
int atoi(char s[])
{
int i, n, sign;
sign = (s[i] == '-') ? -1 : 1;
85
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + s[i];
return sign * n;
}
R. n = 10 * n + s[i]; corect este n = 10 * n + (s[i] - '0');
int atoi(char s[])
{
int i, n, sign;
sign = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return n;
}
R. return n; corect este return sign * n;
spații albe și poate prezenta semnul + sau -. Completați punctele de suspensie pentru a obține un cod
corespunzător unei funcții corecte.
int atoi(char s[])
{
int i, n, sign;
for (i = 0; isspace(......); i++);
sign = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return sign * n;
}
R. s[i]
int atoi(char s[])
{
int i, n, sign;
sign = (s[i] == .... ) ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return sign * n;
}
R. '-'
86
int atoi(char s[])
{
int i, n, sign;
sign = (s[i] == '-') ? .... : 1;
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return sign * n;
}
R. -1
int atoi(char s[])
{
int i, n, sign;
sign = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' ..... s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return sign * n;
}
R. ||
int atoi(char s[])
{
int i, n, sign;
sign = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
.......
n = 10 * n + (s[i] - '0');
return sign * n;
}
R. i++;
int atoi(char s[])
{
int i, n, sign;
sign = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
for (n = 0; isdigit(......); i++)
87
n = 10 * n + (s[i] - '0');
return sign * n;
}
R. s[i]
int atoi(char s[])
{
int i, n, sign;
sign = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return ......;
}
R. sign * n
29. Ce returnează funcția următoare la apelul f(” -123abc”)?

int f(char s[])
{
int i, n, m;
m = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return m * n;
}
R. -123
30. Ce returnează funcția următoare la apelul f(” abc”)?

int f(char s[])
{
int i, n, m;
m = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return m * n;
}
R. 0
31. Ce returnează funcția următoare la apelul f(”ab12”)?

int f(char s[])
{
int i, n, m;
m = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
88
n = 10 * n + (s[i] - '0');
return m * n;
}
R. 0
32. Ce returnează funcția următoare la apelul f(” +12”)?

int f(char s[])
{
int i, n, m;
m = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return m * n;
}
R. 12
33. Ce returnează funcția următoare la apelul f(” +12ab”)?

int f(char s[])
{
int i, n, m;
m = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return m * n;
}
R. 12
34. Ce returnează funcția următoare la apelul f(” -12”)?

int f(char s[])
{
int i, n, m;
m = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return m * n;
}
R. -12
35. Cu ce valoare trebuie să apelăm funcția f() astfel încât aceasta să returneze 123?
int f(char s[])
{
int i, n, m;
m = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return m * n;
89
}
R. 123 care poate fi prefixat de spații și/sau + și postfixat de caractere ne-cifre
36. Cu ce valoare trebuie să apelăm funcția f() astfel încât aceasta să returneze -3?
int f(char s[])
{
int i, n, m;
m = (s[i] == '-') ? -1 : 1;
if (s[i] == '+' || s[i] == '-')
i++;
n = 10 * n + (s[i] - '0');
return m * n;
}
R. -3 care poate fi prefixat de spații și postfixat de caractere ne-cifre
37. Precizați scopul funcției f() de mai jos, știind că funcția reverse(s) inversează șirul s.
void f(int n, char s[])
{
int i, sign;
if ((sign = n) < 0)
n = -n;
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. convertește un număr întreg n la un șir de caractere s
38. Funcția itoa() următoare convertește un număr întreg n la un șir de caractere s; ea conține apelul funcției
reverse(s) care inversează șirul s. Funcția conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și
varianta ei corectă.
void itoa(int n, char s[])
{
int i, sign;
if ((sign == n) < 0)
n = -n;
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. if ((sign == n) < 0) corect este if ((sign = n) < 0)
90
{
int i, sign;
if (sign = n < 0)
n = -n;
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. if (sign = n < 0) corect este if ((sign = n) < 0)
{
int i, sign;
if ((sign = n) < 0)
n = -1;
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. n = -1; corect este n = -n;
{
int i, sign;
if ((sign = n) < 0)
n = -n;
i = 1;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. i = 1; corect este i = 0;
{
int i, sign;
91
if ((sign = n) < 0)
n = -n;
i = 0;
do {
s[i++] = n % 10;
} while ((n /= 10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. s[i++] = n % 10; corect este s[i++] = n % 10 + '0';
{
int i, sign;
if ((sign = n) < 0)
n = -n;
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. while (n > 0); corect este while ((n /= 10) > 0);
{
int i, sign;
if ((sign = n) < 0)
n = -n;
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (n < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. if (n < 0) corect este if (sign < 0)
{
int i, sign;
if ((sign = n) < 0)
n = -n;
92
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign < 0)
s[++i] = '-';
s[i] = '\0';
reverse(s);
}
R. s[++i] = '-'; corect este s[i++] = '-';
{
int i, sign;
if ((sign = n) < 0)
n = -n;
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '0';
reverse(s);
}
R. s[i] = '0'; corect este s[i] = '\0';
reverse(s) care inversează șirul s. Completați punctele de suspensie pentru a obține un cod corespunzător
unei funcții corecte.
{
int i, sign;
if ((.........) < 0)
n = -n;
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. sign = n
{
int i, sign;
if ((sign = n) ..... 0)
n = -n;
i = 0;
do {
93
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. <
{
int i, sign;
if ((sign = n) < 0)
........
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. n = -n;
{
int i, sign;
if ((sign = n) < 0)
n = -n;
i = .....;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. 0
{
int i, sign;
if ((sign = n) < 0)
n = -n;
i = 0;
do {
s[i++] = n % 10 + ......;
} while ((n /= 10) > 0);
94
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. '0'
{
int i, sign;
if ((sign = n) < 0)
n = -n;
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= .....) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. 10
{
int i, sign;
if ((sign = n) < 0)
n = -n;
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) .... 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. >
{
int i, sign;
if ((sign = n) < 0)
n = -n;
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign ....)
s[i++] = '-';
95
s[i] = '\0';
reverse(s);
}
R. < 0
55. Ce returnează funcția următoare la apelul f(-23); ea conține apelul funcției reverse(s) care inversează
șirul s?
{
int i, sign;
if ((sign = n) < 0)
n = -n;
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. -23
56. Ce returnează funcția următoare la apelul f(+14); f conține apelul funcției reverse(s) care inversează
șirul s?
{
int i, sign;
if ((sign = n) < 0)
n = -n;
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. 14
57. Cu ce valoare trebuie să apelăm funcția f() astfel încât aceasta să returneze 10; f conține apelul funcției
reverse(s) care inversează șirul s?
{
int i, sign;
if ((sign = n) < 0)
n = -n;
i = 0;
do {
s[i++] = n % 10 + '0';
} while ((n /= 10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}
R. 10 sau +10
96
int f(char s[])
{
int n;
for (n = strlen(s)-1; n >= 0; n--)
if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
break;
s[n + 1] = '\0';
return n + 1;
}
R. șterge blank-urile, tab-urile şi newline-urile de la sfârșitul unui șir de caractere s[]și întoarce lungimea
șirului rezultat după ștergere
59. Funcția următoare șterge blank-urile, tab-urile şi newline-urile de la sfârșitul unui șir de caractere s[]și
întoarce lungimea șirului rezultat după ștergere. Funcția conține o instrucțiune scrisă greșit. Scrieți instrucțiunea
int trim(char s[])
{
int n;
for (n = strlen(s); n >= 0; n--)
if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
break;
s[n + 1] = '\0';
return n + 1;
}
R. n = strlen(s) corect este n = strlen(s)-1
int trim(char s[])
{
int n;
for (n = strlen(s)-1; n > 0; n--)
if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
break;
s[n + 1] = '\0';
return n + 1;
}
R. n = strlen(s)-1; n > 0; n-- corect este n = strlen(s)-1; n >= 0; n--
int trim(char s[])
{
int n;
for (n = strlen(s)-1; n >= 0; n++)
if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
break;
s[n + 1] = '\0';
return n + 1;
}
R. n = strlen(s)-1; n >= 0; n++ corect este n = strlen(s)-1; n >= 0; n--
97
int trim(char s[])
{
int n;
for (n = strlen(s)-1; n >= 0; n--)
if (s[n] != ' ' || s[n] != '\t' || s[n] != '\n')
break;
s[n + 1] = '\0';
return n + 1;
}
R. s[n]!=' '||s[n]!='\t'||s[n]!='\n' corect este s[n]!=' '&&s[n]!='\t'&&s[n]!='\n'
int trim(char s[])
{
int n;
for (n = strlen(s)-1; n >= 0; n--)
if (s[n] == ' ' || s[n] == '\t' || s[n] == '\n')
break;
s[n + 1] = '\0';
return n + 1;
}
R. s[n]==' '||s[n]=='\t'||s[n]=='\n' corect este s[n]!=' '&&s[n]!='\t'&&s[n]!='\n'
int trim(char s[])
{
int n;
for (n = strlen(s)-1; n >= 0; n--)
if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
break;
s[n] = '\0';
return n + 1;
}
R. s[n] = '\0'; corect este s[n + 1] = '\0';
întoarce lungimea șirului rezultat după ștergere. Completați punctele de suspensie pentru a obține un cod
int trim(char s[])
{
int n;
for (n = ......; n >= 0; n--)
if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
break;
s[n + 1] = '\0';
return n + 1;
}
R. strlen(s)-1
98
int trim(char s[])
{
int n;
for (n = strlen(s)-1; ......; n--)
if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
break;
s[n + 1] = '\0';
return n + 1;
}
R. n >= 0
int trim(char s[])
{
int n;
for (n = strlen(s)-1; n >= 0; n--)
if (...... && s[n] != '\t' && s[n] != '\n')
break;
s[n + 1] = '\0';
return n + 1;
}
R. s[n] != ' '
int trim(char s[])
{
int n;
for (n = strlen(s)-1; n >= 0; n--)
if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
......
s[n + 1] = '\0';
return n + 1;
}
R. break;
int trim(char s[])
{
int n;
for (n = strlen(s)-1; n >= 0; n--)
if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
break;
..... = '\0';
return n + 1;
}
R. s[n + 1]
99
int trim(char s[])
{
int n;
for (n = strlen(s)-1; n >= 0; n--)
if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
break;
s[n + 1] =.....;
return n + 1;
}
R. '\0'
71. Ce returnează funcția următoare la apelul f("abc\n\t ")?

int f(char s[])
{
int n;
for (n = strlen(s)-1; n >= 0; n--)
if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
break;
s[n + 1] = '\0';
return n + 1;
}
R. 3
72. Dacă s conține șirul "abc\n\t " care este conținutul lui s după apelul f(s)?
int f(char s[])
{
int n;
for (n = strlen(s)-1; n >= 0; n--)
if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
break;
s[n + 1] = '\0';
return n + 1;
}
R. abc
73. Dacă s conține șirul "\n\t abc" care este conținutul lui s după apelul f(s)?
int f(char s[])
{
int n;
for (n = strlen(s)-1; n >= 0; n--)
if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
break;
s[n + 1] = '\0';
return n + 1;
}
R. "\n\t abc"
74. Dacă s conține șirul "\n\t abc\n\t " care este conținutul lui s după apelul f(s)?
int f(char s[])
{
int n;
for (n = strlen(s)-1; n >= 0; n--)
if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
break;
100
s[n + 1] = '\0';
return n + 1;
}
R. "\n\t abc"
75. Dacă s conține șirul "\n\t abc\n\t " care este valoarea returnată de funcția f() după apelul f(s)?
int f(char s[])
{
int n;
for (n = strlen(s)-1; n >= 0; n--)
if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
break;
s[n + 1] = '\0';
return n + 1;
}
R. 6
76. Care este valoarea variabilei found după parcurgerea secvenței de cod următoare:
int found = 0, i, j, n = 5, m = 5, a[10] = {1, -2, 5, 8, 7}, b[7] = {2, 9, -1, 4, 8};
for (i = 0; i < n && !found; i++)
for (j = 0; j < m && !found; j++)
if (a[i] == b[j])
found = 1;
R. 1
77. Care este valoarea variabilei i după parcurgerea secvenței de cod următoare:
int found = 0, i, j, n = 5, m = 5, a[10] = {1, -2, 5, 8, 7}, b[7] = {2, 9, -1, 4, 8};
for (i = 0; i < n && !found; i++)
for (j = 0; j < m && !found; j++)
if (a[i] == b[j])
found = 1;
R. 4
78. Care este valoarea variabilei j după parcurgerea secvenței de cod următoare:
int found = 0, i, j, n = 5, m = 5, a[10] = {1, -2, 5, 8, 7}, b[7] = {2, 9, -1, 4, 8};
for (i = 0; i < n && !found; i++)
for (j = 0; j < m && !found; j++)
if (a[i] == b[j])
found = 1;
R. 5
79. Care este valoarea elementului b[j] după parcurgerea secvenței de cod următoare:
int found = 0, i, j, n = 5, m = 5, a[10] = {1, -2, 5, 8, 7}, b[7] = {2, 9, -1, 4, 8};
for (i = 0; i < n && !found; i++)
for (j = 0; j < m && !found; j++)
if (a[i] == b[j])
found = 1;
R. 0
80. Care este valoarea elementului a[i] după parcurgerea secvenței de cod următoare:
int found = 0, i, j, n = 5, m = 5, a[10] = {1, -2, 5, 8, 7}, b[7] = {2, 9, -1, 4, 8};
for (i = 0; i < n && !found; i++)
for (j = 0; j < m && !found; j++)
101
if (a[i] == b[j])
found = 1;
R. 7
81. Precizați scopul secvenței de cod de mai jos, dacă a și b sunt două tablouri unidimensionale de n, respectiv
m elemente.
found = 0;
for (i = 0; i < n && !found; i++)
for (j = 0; j < m && !found; j++)
if (a[i] == b[j])
found = 1;
R. determină dacă a[] şi b[] au un element în comun.
82. Secvența următoare determină dacă două tablouri unidimensionale a[] şi b[] de n, respectiv m elemente au
un element în comun. Secvența conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și varianta ei
corectă.
found = 0;
for (i = 0; i < n && !found; i++)
for (j = 0; j < m && !found; j++)
if (a[i] = b[j])
found = 1;
R. if (a[i] = b[j]) corect este if (a[i] == b[j])
83. Secvența următoare determină dacă două tablouri unidimensionale a[] şi b[] de n, respectiv m elemente au
un element în comun. Completați punctele de suspensie pentru a obține un cod corespunzător unei secvențe
corecte.
found = 0;
for (i = 0; i < n && !found; i++)
for (j = 0; j < m && !found; j++)
if (.....)
found = 1;
R. a[i] == b[j]
84. Dacă avem declarația int n = 5, m = 5, x[10] = {1, -2, 5, 8, 7}, y[7] = {2, 9, -1, 4, 8};
Ce returnează funcția următoare la apelul f(x, n, y, m)?
int f(int a[], int na, int b[], int nb)
{
int i, j;
for(i = 0; i < na; i++)
for(j = 0; j < nb; j++)
if(a[i] == b[j])
return i;
return -1;
}
R. 3
85. Dacă avem declarația int x[10] = {1, -2, 5, 18, 7}, y[7] = {2, 9, -1, 4, 8}; Ce returnează
funcția următoare la apelul f(x, 5, y, 5)?
{
int i, j;
for(i = 0; i < na; i++)
for(j = 0; j < nb; j++)
102
if(a[i] == b[j])
return i;
return -1;
}
R. -1
86. Dacă avem declarația int x[10] = {1, -2, 5, 8, 7}, y[7] = {2, 9, -1, 4, 8}; Cu ce valoare
pentru n trebuie să apelăm funcția f(x, n, y, 5) astfel încât aceasta să returneze -1 ?
{
int i, j;
for(i = 0; i < na; i++)
for(j = 0; j < nb; j++)
if(a[i] == b[j])
return i;
return -1;
}
R. 3, 2, 1 sau 0
87. Dacă avem declarația int x[10] = {1, -2, 5, 8, 7}, y[7] = {2, 9, -1, 4, 8}; Cu ce valoare
pentru m trebuie să apelăm funcția f(x, 5, y, m) astfel încât aceasta să returneze -1 ?
{
int i, j;
for(i = 0; i < na; i++)
for(j = 0; j < nb; j++)
if(a[i] == b[j])
return i;
return -1;
}
R. 4, 3, 2, 1 sau 0
88. Dacă avem declarația int x[10] = {1, -2, 5, 8, 7}, y[7] = {2, 9, -1, 4, 8}; Ce valori poate
lua n în apelul f(x, n, y, 5) astfel încât funcția f() să returneze o valoare diferită de -1 ?
{
int i, j;
for(i = 0; i < na; i++)
for(j = 0; j < nb; j++)
if(a[i] == b[j])
return i;
return -1;
}
R. o valoare întreagă mai mare sau egală cu 4 și mai mică sau egală cu 10
89. Dacă avem declarația int x[10] = {1, -2, 5, 8, 7}, y[7] = {2, 9, -1, 4, 8}; Ce valori poate
lua m în apelul f(x, 5, y, m) astfel încât funcția f() să returneze o valoare diferită de -1 ?
{
int i, j;
for(i = 0; i < na; i++)
for(j = 0; j < nb; j++)
if(a[i] == b[j])
return i;
return -1;
}
103
R. o valoare întreagă mai mare sau egală cu 5 și mai mică sau egală cu 7
90. Funcția următoare determină dacă două tablouri unidimensionale de numere întregi x[] şi y[] de n,
respectiv m elemente, au un element în comun, returnând poziția din tabloul x[] a elementului comun, respectiv
-1, dacă cele două tablouri nu au niciun element în comun. Funcția conține o instrucțiune scrisă greșit. Scrieți
int f(int x[], int n, int y[], int m)
{
int i, j;
for(i = 0; i < n; i++)
for(j = 0; j < m; j++)
if(x[i] = y[j])
return i;
return -1;
}
R. if(x[i] = y[j]) corect este if(x[i] == y[j])
int f(int x, int n, int y, int m)
{
int i, j;
for(i = 0; i < n; i++)
for(j = 0; j < m; j++)
if(x[i] == y[j])
return i;
return -1;
}
R. int f(int x, int n, int y, int m) corect este int f(int x[], int n, int y[], int m)
int f(int x[], int n, int y[], int m);
{
int i, j;
for(i = 0; i < n; i++)
for(j = 0; j < m; j++)
if(x[i] == y[j])
return i;
return -1;
}
R. int f(int x[], int n, int y[], int m); corect este int f(int x[], int n, int y[], int m)
-1, dacă cele două tablouri nu au niciun element în comun. Completați punctele de suspensie pentru a obține un
cod corespunzător unei secvențe corecte.
{
int i, j;
for(i = 0; i < n; i++)
for(j = 0; j < m; j++)
if(x[i] == y[j])
104
......
return -1;
}
R. return i;
-1, dacă cele două tablouri nu au niciun element în comun. Completați punctele de suspensie pentru a obține un
cod corespunzător unei secvențe corecte.
{
int i, j;
for(i = 0; i < n; i++)
for(j = 0; j < m; j++)
if(x[i] == y[j])
return i;
.......
}
R. return -1;

double f(char sir[])
{
double n, z;
int i, s;
for (i = 0; isspace(sir[i]); i++)
;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
for (n = 0.0; isdigit(sir[i]); i++)
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
for (z = 1.0; isdigit(sir[i]); i++) {
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. convertește un șir de caractere la numărul real corespunzător
96. Funcția următoare convertește un șir de caractere la numărul real corespunzător. Funcția conține o
instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și varianta ei corectă.
{
double n, z;
int i, s;
for (i = 0; isdigit(sir[i]); i++);
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
105
return s * n / z;
}
R. for (i = 0; isdigit(sir[i]); i++); corect este for (i = 0; isspace(sir[i]); i++);
{
double n, z;
int i, s;
for (i = 0; isspace(sir[i]); i++);
s = (sir[i] == '+') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. s = (sir[i] == '+') ? -1 : 1; corect este s = (sir[i] == '-') ? -1 : 1;
{
double n, z;
int i, s;
s = (sir[i] == '-') ? 1 : -1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. s = (sir[i] == '-') ? 1 : -1; corect este s = (sir[i] == '-') ? -1 : 1;
{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' && sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
106
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. if (sir[i] == '-' && sir[i] == '+') corect este if (sir[i] == '-' || sir[i] == '+')
{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i--;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. if(sir[i]=='-'||sir[i]=='+') i++; corect este if(sir[i]=='-'||sir[i]=='+') i++;
{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
for (n = 0.0; isspace(sir[i]); i++)
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. for(n=0.0; isspace(sir[i]); i++) corect este for(n=0.0; isdigit(sir[i]); i++)
{
double n, z;
int i, s;
107
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i--;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. if (sir[i] == '.') i--; corect este if (sir[i] == '.') i++;
{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z /= 10;
}
return s * n / z;
}
R. z /= 10; corect este z *= 10;
{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s / n * z;
}
R. return s / n * z; corect este return s * n / z;
108
105. Funcția următoare convertește un șir de caractere la numărul real corespunzător. Completați punctele de
suspensie pentru a obține un cod corespunzător unei funcții corecte.
{
double n, z;
int i, s;
for (i = 0;..........; i++);
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. isspace(sir[i])
{
double n, z;
.........
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. int i, s;
{
double n, z;
int i, s;
s = (sir[i] == '-') ? ....;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
109
return s * n / z;
}
R. -1 : 1
{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (........|| sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. sir[i] == '-'
{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || ....)
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. sir[i] == '+'
{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
for (n = 0.0;.........; i++)
n = 10.0 * n + (sir[i] - '0');
110
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. isdigit(sir[i])
{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + ......;
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. (sir[i] - '0')
{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == .... )
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. '.'
{
double n, z;
int i, s;
111
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
.......
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. i++;
{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
for (z = 1.0; .....; i++) {
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. isdigit(sir[i])
{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
......
}
return s * n / z;
}
R. z *= 10;
112
{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return .....;
}
R. s * n / z
117. Ce returnează funcția următoare la apelul f("\n\t -123.25")?

{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. -123.25
118. Ce returnează funcția următoare la apelul f("\n\t +3.025")?

{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
113
R. 3.025
119. Cu ce valoare trebuie să apelăm funcția f() astfel încât aceasta să returneze 17.07 ?
{
double n, z;
int i, s;
s = (sir[i] == '-') ? -1 : 1;
if (sir[i] == '-' || sir[i] == '+')
i++;
n = 10.0 * n + (sir[i] - '0');
if (sir[i] == '.')
i++;
n = 10.0 * n + (sir[i] - '0');
z *= 10;
}
return s * n / z;
}
R. 17.07 prefixat sau nu de + și de spații albe și sufixat de orice caracter ne-cifră

int f(char x[], char y[])
{
int i, j, k;
for (i = 0; x[i] != '\0'; i++) {
for (j=i, k=0; y[k]!='\0' && x[j]==y[k]; j++, k++);
if (k > 0 && y[k] == '\0')
return i;
}
return -1;
}
R. returnează poziția primei apariții a șirului y[] în șirul x[], sau -1 dacă y[] nu apare în x[]
121. Funcția următoare returnează poziția primei apariții a șirului y[] în șirul x[], sau -1 dacă y[] nu apare în
x[]. Funcția conține o instrucțiune scrisă greșit. Scrieți instrucțiunea greșită și varianta ei corectă.
{
int i, j, k;
for (i = 0; x[i] == '\0'; i++) {
for (j=i, k=0; y[k]!='\0' && x[j]==y[k]; j++, k++);
if (k > 0 && y[k] == '\0')
return i;
}
return -1;
}
R. for (i = 0; x[i] == '\0'; i++) corect este for (i = 0; x[i] != '\0'; i++)
{
int i, j, k;
for (i = 0; x[i] != '\0'; i++) {
for (j=i, k=0; y[k]!='\0' && x[j]==y[k]; j++);
if (k > 0 && y[k] == '\0')
114
return i;
}
return -1;
}
R. for(j=i,k=0;y[k]!='\0'&&x[j]==y[k];j++) corect este

for(j=i,k=0;y[k]!='\0'&&x[j]==y[k];j++,k++)
{
int i, j, k;
for (i = 0; x[i] != '\0'; i++) {
for (j=i, k=0; y[k]!='\0' && x[j]==y[k]; j++, k++);
if (k > 0 && y[k] != '\0')
return i;
}
return -1;
}
R. if(k>0&&y[k]!='\0') corect este if(k>0&&y[k]=='\0')
{
int i, j, k;
for (i = 0; x[i] != '\0'; i++) {
for (j=i, k=0; y[k]!='\0' && x[j]==y[k]; j++, k++);
if (k > 0 && y[k] == '\0')
return k;
}
return -1;
}
R. return k; corect este return i;
{
int i, j, k;
for (i = 0; x[i] != '\0'; i++) {
for (j=i, k=0; y[k]!='\0' && x[j]==y[k]; j++, k++);
if (k > 0 && y[k] == '\0')
return i;
}
return k;
}
R. return k; corect este return -1;
x[]. Completați punctele de suspensie pentru a obține un cod corespunzător unei funcții corecte.
.... f(char x[], char y[])
{
int i, j, k;
for (i = 0; x[i] != '\0'; i++) {
for (j = i, k = 0; y[k]! = '\0' && x[j] == y[k]; j++, k++);
if (k > 0 && y[k] == '\0')
115
return i;
}
return -1;
}
R. int
{
... i, j, k;
for (i = 0; x[i] != '\0'; i++) {
for (j = i, k = 0; y[k]! = '\0' && x[j] == y[k]; j++, k++);
if (k > 0 && y[k] == '\0')
return i;
}
return -1;
}
R. int
{
int i, j, k;
for (i = 0; x[i] != ...; i++) {
for (j = i, k = 0; y[k]! = '\0' && x[j] == y[k]; j++, k++);
if (k > 0 && y[k] == '\0')
return i;
}
return -1;
}
R. '\0'
{
int i, j, k;
for (i = 0; x[i] != '\0'; i++) {
for (j = i, k = ...; y[k]! = '\0' && x[j] == y[k]; j++, k++);
if (k > 0 && y[k] == '\0')
return i;
}
return -1;
}
R. 0
{
int i, j, k;
for (i = 0; x[i] != '\0'; i++) {
for (j = i, k = 0; y[k]! = '\0' && x[j] == ...; j++, k++);
if (k > 0 && y[k] == '\0')
return i;
116
}
return -1;
}
R. y[k]
{
int i, j, k;
for (i = 0; x[i] != '\0'; i++) {
for (j = i, k = 0; y[k]! = '\0' && x[j] == y[k]; j++, ...);
if (k > 0 && y[k] == '\0')
return i;
}
return -1;
}
R. k++
{
int i, j, k;
for (i = 0; x[i] != '\0'; i++) {
for (j = i, k = 0; y[k]! = '\0' && x[j] == y[k]; j++, k++);
if (k > 0 && ....== '\0')
return i;
}
return -1;
}
R. y[k]
133. Ce returnează funcția următoare la apelul f("pascal", "sc")?

{
int i, j, k;
for (i = 0; x[i] != '\0'; i++) {
for (j = i, k = 0; y[k]! = '\0' && x[j] == y[k]; j++, k++);
if (k > 0 && y[k] == '\0')
return i;
}
return -1;
}
R. 2
134. Ce returnează funcția următoare la apelul f("pascal", "pac")?

{
int i, j, k;
for (i = 0; x[i] != '\0'; i++) {
for (j = i, k = 0; y[k]! = '\0' && x[j] == y[k]; j++, k++);
if (k > 0 && y[k] == '\0')
return i;
}
return -1;
}
117
R. -1
135. Ce returnează funcția următoare la apelul f("knosos", "os")?

{
int i, j, k;
for (i = 0; x[i] != '\0'; i++) {
for (j = i, k = 0; y[k]! = '\0' && x[j] == y[k]; j++, k++);
if (k > 0 && y[k] == '\0')
return i;
}
return -1;
}
R. 2
136. Dacă variabila x are valoarea ”atomic”, ce valoare trebuie să aibă variabila y, astfel încât la apelul f(x,
y) să se returneze 3 ?
{
int i, j, k;
for (i = 0; x[i] != '\0'; i++) {
for (j = i, k = 0; y[k]! = '\0' && x[j] == y[k]; j++, k++);
if (k > 0 && y[k] == '\0')
return i;
}
return -1;
}
R. ”m”, ”mi” sau ”mic”

{
int i, j, n = strlen(x) - strlen(y);
while (n >= 0) {
for (i = n, j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
return -1;
}
R. returnează poziția celei mai din dreapta apariții a șirului de caractere y în șirul de caractere x, sau -1 dacă
șirul y nu apare deloc în șirul x
138. Funcția următoare returnează poziția celei mai din dreapta apariții a șirului de caractere y în șirul de
caractere x, sau -1 dacă șirul y nu apare deloc în șirul x. Funcția conține o instrucțiune scrisă greșit. Scrieți
{
int i, j, n = strlen(x);
while (n >= 0) {
for (i = n, j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
return -1;
118
}
R. n = strlen(x); corect este n = strlen(x) - strlen(y)
{
int i, j, n = strlen(y);
while (n >= 0) {
for (i = n, j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
return -1;
}
R. n = strlen(y); corect este n = strlen(x) - strlen(y);
{
while (n > 0) {
for (i = n, j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
return -1;
}
R. while (n > 0) corect este while (n >= 0)
{
while (n >= 0) {
for (i = 0, j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
return -1;
}
R. for (i = 0, j = 0; corect este for (i = n, j = 0;
{
119
while (n >= 0) {
for (i = n, j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return j;
n--;
}
return -1;
}
R. return j; corect este return n;
caractere x, sau -1 dacă șirul y nu apare deloc în șirul x. Completați punctele de suspensie pentru a obține un
cod corespunzător unei funcții corecte.
{
while (n >= 0) {
for (i = n, j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
.........;
}
R. return -1
{
int i, j, n = .........- strlen(y);
while (n >= 0) {
for (i = n, j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
return -1;
}
R. strlen(x)
{
while (.........) {
for (i = n, j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
return -1;
}
R. n >= 0
120
{
while (n >= 0) {
for (i =....., j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
return -1;
}
R. n
{
while (n >= 0) {
for (i = n, j = 0; y[j] != '\0' && x[i] == y[j]; ++i,.....);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
return -1;
}
R. ++j
148. Ce returnează funcția următoare la apelul f(”knosos”, ”os”)?

{
while (n >= 0) {
for (i = n, j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
return -1;
}
R. 4
149. Ce returnează funcția următoare la apelul f(”knosos”, ”ns”)?

{
while (n >= 0) {
for (i = n, j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
return -1;
}
121
R. -1
150. Ce returnează funcția următoare la apelul f(”on”, ”on”)?

{
while (n >= 0) {
for (i = n, j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
return -1;
}
R. 0
151. Ce returnează funcția următoare la apelul f(”aaaa”, ”a”)?

{
while (n >= 0) {
for (i = n, j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
return -1;
}
R. 3
152. Dacă variabila x are valoarea ”knosos”, ce valoare trebuie să aibă variabila y, astfel încât la apelul f(x,
y) să se returneze 4?
{
while (n >= 0) {
for (i = n, j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
return -1;
}
R. os
153. Dacă variabila x are valoarea ”knosos”, ce valoare trebuie să aibă variabila y, astfel încât la apelul f(x,
y) să se returneze 2 ?
{
while (n >= 0) {
for (i = n, j = 0; y[j] != '\0' && x[i] == y[j]; ++i, ++j);
if (j > 0 && y[j] == '\0')
return n;
n--;
}
return -1;
122
}
R. ”oso” sau ”osos”
154. Care este valoarea lui k la finalul secvenței de mai jos?
float a[10] = {3, -2.06, 4.25, -3.09, 9.01, 8.99, -0.56};

int i, k = 0, n = 7;
for (i = 0; i < n; i++){
if (a[i] < 0)
continue;
else
++k;
}
R. 4
155. Care este valoarea lui i la finalul secvenței de mai jos?

float a[10] = {3, -2.06, 4.25, -3.09, 9.01, 8.99, -0.56};
int i, k = 0, n = 7;
for (i = 0; i < n; i++){
if (a[i] < 0)
continue;
else
++k;
}
R. 7
156. Secvența următoare calculează în variabila k numărul de elemente pozitive din tabloul a. Completați
punctele de suspensie pentru a obține un cod corespunzător unei funcționări corecte.
float a[10] = {3, -2.06, 4.25, -3.09, 9.01, 8.99, -0.56};
int i, k = 0, n = 7;
for (i = 0; i < n; i++){
if (.....)
continue;
else
++k;
}
R. a[i] < 0
157. Secvența următoare calculează în variabila k numărul de elemente pozitive din tabloul a. Completați
punctele de suspensie cu instrucțiunea corespunzătoare pentru a obține o funcționare corectă.
float a[10] = {3, -2.06, 4.25, -3.09, 9.01, 8.99, -0.56};
int i, k = 0, n = 7;
for (i = 0; i < n; i++){
if ( a[i] < 0 )
........ ;
else
++k;
}
R. continue sau nimic
158. Secvența următoare calculează în variabila k numărul de elemente pozitive din tabloul a. Secvența conține
float a[10] = {3, -2.06, 4.25, -3.09, 9.01, 8.99, -0.56};
int i, k = 0, n = 7;
for (i = 0; i < n; i++){
123
if (a[i] < 0)
break;
else
++k;
}
R. break corect este continue (sau nimic)
159. Secvența următoare calculează în variabila k numărul de elemente pozitive din tabloul a. Care este cea mai
mare valoare cu care trebuie să îl inițializăm pe n astfel încât, la finalul secvenței k să aibă valoarea 2 ?
float a[10] = {3, -2.06, 4.25, -3.09, 9.01, 8.99, -0.56};
int i, k = 0, n = ?;
for (i = 0; i < n; i++){
if (a[i] < 0)
continue;
else
++k;
}
R. n = 4
160. Care este valoarea variabilei t la finalul secvenței următoare ?

float a[10] = {3, -2.06, 4.25, -3.09, 9.01, 8.99, -0.56};
int i, k = 0, n = 7, t = 0;
for (i = 0; i < n; i++){
if (a[i] < 0){
continue;
++t;
}
else
++k;
}
R. t = 0
124

PCLP Laborator 9 PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

PCLP Laborator 9 PDF

Încărcat de

Drepturi de autor:

Formate disponibile

LABORATOR 9

1. În programul de mai jos, în suma(x,y); x şi y reprezintă ….

2. În codul funcţiei suma de mai jos, primul cuvânt int, reprezintă ….

3. În codul funcţiei suma de mai jos, a şi b, reprezintă …..

4. Parametrii actuali şi cei formali trebuie să corespundă ca ……….

5. Parametrii …. substituie la apel parametrii …...

7. Variabilele automate sunt externe tuturor funcţiilor.

14. În programul de mai jos suma(x,y); reprezintă ….

15. O variabilă locală este o variabilă ….

R. int n, i, prim = 0; corect este int n, i, prim = 1;

18. Ce afișează programul următor dacă se citește de la tastatură n = 25 ?

R. orice număr prim

R. if ( i%n == 0 ) corect este if ( n%i == 0 )

R. for(i = 1; i<=n-1; ++i ) corect este for(i=2; i<=n-1; ++i )

R. for(i=2; i<=n; ++i) corect este for(i=2; i<n; ++i)

R. n == 0 || n == 1 sau n<2 sau n<=1

R. if( n%2 == 1) corect este if( n%2 == 0)

R. for ( i = 3; i <= sqrt(n); i = i + 2 ) sau în loc de sqrt(n): n/2 sau n-1

27. Ce afișează programul următor dacă se citește de la tastatură 7 ?

28. Ce trebuie să citim pe intrare astfel încât programul să afișeze 0 ?

R. orice număr ne-prim

R. for ( i = 1; i < n; ++i ) corect este for ( i = 1; i <= n; ++i )

31. Ce afișează programul următor dacă se citește de la tastatură 7 ?

32. Ce trebuie să citim pe intrare astfel încât programul să afișeze 111 ?

33. Precizați scopul programului de mai jos?

R. afișează toți divizorii unui număr natural dat

36. Ce afișează programul următor dacă se citește de la tastatură 0 ?

37. Ce afișează programul următor dacă se citește de la tastatură 12 ?

38. Ce trebuie să citim pe intrare astfel încât programul să afișeze 1824 ?

39. Precizați scopul programului de mai jos?

R. afișează toți divizorii unui număr natural dat

R. #include <stdio.h> #include <math.h>

R. ++d; sau d++; sau d = d + 1;

46. Ce afișează programul următor dacă se citește de la tastatură 96 ?

47. Ce afișează programul următor dacă se citește de la tastatură 96 ?

48. Ce afișează programul următor dacă se citește de la tastatură 1 ?

R. acel număr prim care se dorește afișat

51. Precizați scopul programului de mai jos?

R. afișează descompunerea în factori primi a unui număr natural n citit de la tastatură

R. if ( n < m ) corect este if ( n > m )

R. if(n!=m) corect este while(n!=m)

R. while(n!=0) corect este while(n!=m)

57. Ce afișează programul următor dacă se citește de la tastatură 96 60 ?

58. Ce trebuie să citim pe intrare astfel încât programul să afișeze 1 ?

59. Precizați scopul programului de mai jos?

R. calculează cmmdc(n, m) pentru două numere naturale nenule n și m

R. while ( n != 0 ) corect este while ( m != 0 )

R. printf("%d", m); corect este printf("%d", n);

63. Ce afișează programul următor dacă se citește de la tastatură 96 36 ?

R. 1 sau orice număr prim cu 4

R. calculează cmmdc(n, m) pentru două numere naturale nenule n și m

R. temp = temp/10; corect este temp = temp/b;

R. z = z * b; corect este z = z * 10;

R. nb = nb + z * (temp%10); corect este nb = nb + z * (temp%b);

72. Ce afișează programul următor dacă se citește de la tastatură 12 2 ?

74. Precizați scopul programului de mai jos?

R. convertește numărul n, din baza 10 în baza m (2 <= m <= 9)

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

R. printf("cmmmc(%d,%d)=%d",n,m,x/n*m); corect este printf("cmmmc(%d,%d)=%d",n,m,n*m/x);

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

77. Ce afișează programul următor dacă se citește de la tastatură 35 25 ?

R. nb = nb/b; corect este nb = nb/10;

R. z = z * 10; corect este z = z * b;

R. printf("cmmmc(%d,%d)=%d",n,m,x/nm); corect este printf("cmmmc(%d,%d)=%d",n,m,nm/x);