XBV0XmiY

1#include<stdio.h>
2#include<stdlib.h>
3#include<time.h>
4#pragma warning(disable:4996)
5
6int main()
7{
8	int op, i, n = 0, cate, corect = 0, var, foste[32], nerep;
9
10	for (cate = 1; cate <= 30; cate++)
11	{
12		srand(time(NULL));
13		op = rand() % (150) + 0;
14		do {
15			nerep = 0;
16			for (i = 0; i <= 29; i++)
17			{
18				if (op == foste[i])
19				{
20					srand(time(NULL));
21					op = rand() % (150) + 0;
22					nerep = 1;
23					break;
24				}
25			}
26		} while (nerep);
27		foste[n] = op;
28		n++;
29		printf("\nIntrebarea %d", cate);
30		switch (op) {
31		case 1:
32			printf("\nUn obiect este :\n1). o instanţiere a unei clase;    \n2)o abstractizare a unei clase;\n3)o structură a clasei.\n");
33			scanf("%d", &var);
34			if (var == 1)
35			{
36				printf("\nCorect");
37				corect++;
38			}
39			else
40				printf("\nIncorect 1");
41			break;
42		case 2:
43			printf("\n.O funcţie friend :\n1)poate fi declarată static;\n2)	b. nu poate fi declarată static sau extern;\n3)	c. poate fi declarată static dacă clasa prietenă nu are moştenitori..\n");
44			scanf("%d", &var);
45			if (var == 2)
46			{
47				printf("\nCorect");
48				corect++;
49			}
50			else
51				printf("\nIncorect 2");
52			break;
53		case 3:
54			printf("\n3.Utilizarea funcţiilor inline este recomandată pentru :\n1)	a. funcţii recursive;\n2)	b. funcţii optimale;\n3)p	c. funcţii scurte..\n");
55			scanf("%d", &var);
56			if (var == 3)
57			{
58				printf("\nCorect");
59				corect++;
60			}
61			else
62				printf("\nIncorect 3");
63			break;
64		case 4:
65			printf("\n4.În cadrul unei clase, declararea unei variabile static :\n1)	a. alocă o singură dată memorie;\n2)	b. alocă memorie la fiecare creeare a unui obiect de tipul clasei;\n3)	c. nu alocă memorie pentru aceasta.\n");
66			scanf("%d", &var);
67			if (var == 3)
68			{
69				printf("\nCorect");
70				corect++;
71			}
72			else
73				printf("\nIncorect 3");
74			break;
75		case 5:
76			printf("\n5.În fragmentul de mai jos este eronată linia-sursă nr.:class stiva{			//1\nint stiv[size];		//2\n	public:				//3\n	int virf_stiva;		//4\nvoid init();		//5\nvoid pune(int);		//6\nint scoate();		//7\n};				//8\n...\nmain()				//9\n{				//10\nstiva st1, st2;			//11\nst1.pune(44);			//12\nst2.pune(122);			//13\n			st1.virf_stiva = 11;		//14\n			cout << st1.scoate() << ”\n”;		//15\n	cout << st2.scoate() << ”\n”;		//16\n			return 0;				//17\n		}				//18\n\n1)a)	6,13\n2)b)	14\n3)c)	Nici o linie\n");
77			scanf("%d", &var);
78			if (var == 3)
79			{
80				printf("\nCorect");
81				corect++;
82			}
83			else
84				printf("\nIncorect 3");
85			break;
86		case 6:
87			printf("\n.Dacă se pasează un obiect către o funcţie, constructorul :\n1)	a. va fi apelat întotdeaunaş\n2)	b. va fi apelat pentru anumite tipuri de funcţii;\n3)	c. nu este executat.\n");
88			scanf("%d", &var);
89			if (var == 3)
90			{
91				printf("\nCorect");
92				corect++;
93			}
94			else
95				printf("\nIncorect 3");
96			break;
97		case 7:
98			printf("\nO variabilă membră a unei clase poate fi declarată astfel :\n1)	a. de orice tip;\n2)	b. nu poate fi declarată auto, extern sau register;\n3)c. poate fi doar char, integer sau float..\n");
99			scanf("%d", &var);
100			if (var == 2)
101			{
102				printf("\nCorect");
103				corect++;
104			}
105			else
106				printf("\nIncorect 2");
107			break;
108		case 8:
109			printf("\nCe se întâmplă la compilarea următorului program?\n...\n				class cl {\n				int i;\n				public:\n					cl(int j) { i = j; }\n					int ret_i() { return i; }\n			};\...\n				main()\n			{ \n		cl a[5];\n				...			\n}\n			\n1). Se semnalează eroare de compilare la declararea matricii de obiecte;\n2)Programul este corect;\n3)Se semnalează warning (atenţionare) la constructorul clasei.\n");
110			scanf("%d", &var);
111			if (var == 1)
112			{
113				printf("\nCorect");
114				corect++;
115			}
116			else
117				printf("\nIncorect 1");
118			break;
119		case 9:
120			printf("\nO clasă derivată are acces:\n1)	a. la propriii membri şi la toţi membrii clasei de bază;\n2)	b. la funcţiile sale membre şi la variabilele membre ale clasei de bază;\n3)	c. la propriii membri şi la membrii publici ai clasei de bază.\n");
121			scanf("%d", &var);
122			if (var == 3)
123			{
124				printf("\nCorect");
125				corect++;
126			}
127			else
128				printf("\nIncorect 3");
129			break;
130		case 10:
131			printf("\nCare este sintaxa corectă la iniţializare pentru clasa următoare?\nclass cl {\n			int i, j\npublic:\ncl(int k, int l) { i = k; j = l; }\n					int ret_i() { return i; }\n					int ret_j() { return j; }\n			};				\n1)a.cl ob[3] = (1, 2), \n				(3, 4), \n				(5, 6);\n	\n2). cl ob[3]={(1,2),(3,4),(5,6)};\n3). cl ob[3]= { cl(1,2),\n cl(3, 4),\n cl(5, 6)\n};\n");
132			scanf("%d", &var);
133			if (var == 3)
134			{
135				printf("\nCorect");
136				corect++;
137			}
138			else
139				printf("\nIncorect 3");
140			break;
141		case 11:
142			printf("\nCare linie din programul de mai jos este eronată ?\nclass baza {					//1\nint i;					//2\npublic:						//3\nvoid set_i(int val) { i = val; }		//4\n					int ret_i() { return i; }			//5\n			};						//6\nclass derivat::public baza {			//7\nint j;					//8\npublic:						//9\nvoid set_j(int val) { j = val; }		//10\nint ret_j() { return j; }			//11\n};						//12\n			...\nmain()						//13\n{						//14\n				baza *b;					//15\n				derivat d;				//16\n				b = &d;					//17\nb->set_i(5);				//18\n				b->ret_i();				//19\n				b->set_j(55);				//20\n				return 0;					//21\n			}						//22\n\n1)a)	19\n2)b)	17\n3)c)	20\n");
143			scanf("%d", &var);
144			if (var == 3)
145			{
146				printf("\nCorect");
147				corect++;
148			}
149			else
150				printf("\nIncorect 3");
151			break;
152		case 12:
153			printf("\nÎn programul următor, se va semnala eroare. De ce?\n				class baza {\n								protected:	int i, j;\n				public:\n					void set_ij(int a, int b) { i = a;j = b; }\n					void arata_ij() { cout << i << ”” << j << ”\n”; }\n			};\n			class derivat : protected baza {\n									int k;\n			public:\n				void set_k(int a, int b) { set_ij(a, b); k = i*j; }\n				void arata_ijk() { cout << k << ””;arata_ij(); }\n			};\n			...\n				main() {\n				derivat obd;	\n					obd.set_ij(1, 2);	\n				obd.set_k(3);	\n					obd.arata_ijk();	\n					return 0;\n			}\n			\n1). În definirea funcţiei set_k nu poate apare apelul la set_ij().\n2). i şi j trebuie declarate public în clasa de bază;\n3). set_ij nu poate fi apelat asociat obiectului obd        deoarece 		funcţia respectivă este membră protejată pentru clasa derivată\n");
154			scanf("%d", &var);
155			if (var == 3)
156			{
157				printf("\nCorect");
158				corect++;
159			}
160			else
161				printf("\nIncorect 3");
162			break;
163		case 13:
164			printf("\n13.Constructorul clasei derivate :\n1)	a. trebuie în general să declare atât parametrii proprii de apel cât şi parametrii de apel ai clasei de bază;\n2)	b. nu trebuie să declare parametrii constructorului clasei de bază;\n3)	c. nu are voie să conţină declaraţii ale parametrilor de apel ai clasei de bază.\n");
165			scanf("%d", &var);
166			if (var == 1)
167			{
168				printf("\nCorect");
169				corect++;
170			}
171			else
172				printf("\nIncorect 1");
173			break;
174		case 14:
175			printf("\n.Funcţiilor friend :\n1)	a. nu le sunt pasaţi pointeri this;\n2)	b. le sunt pasaţi pointeri this;\n3)	c. le sunt pasaţi pointeri this de tip special.\n");
176			scanf("%d", &var);
177			if (var == 1)
178			{
179				printf("\nCorect");
180				corect++;
181			}
182			else
183				printf("\nIncorect 1");
184			break;
185
186		case 15:
187			printf("\nInstrucţia marcată cu „S” este :\n				class clasa_ex {\n				int i, j;\n				public:\n					clasa_ex(int v_init1, int v_init2) { i = v_init1; j = v_init2; }\n					...\n		};\n			...\n				main() {\n				clasa_ex exemplu(5, 55);		//”S”\n				...		\n			return 0;	\n					}		\n");			
188	
189			printf("\n1)a.incorectă;\n");
190			printf("\n2)b.corectă;\n");
191			printf("\n3)c.incorectă în cele mai multe contexte;\n");
192			scanf("%d", &var);
193			if (var == 2)
194			{
195				printf("\nCorect");
196				corect++;
197			}
198			else
199				printf("\nIncorect 2");
200			break;
201		case 16:
202			printf("\n16.Funcţiile virtuale:");
203			printf("\n1)	a. pot fi membri statici ai unei clase\n");
204			printf("\n2)	b. nu pot fi membri statici ai unei clase\n");
205			printf("\n3)	c. pot fi membri statici doar într-o clasă derivată şi dacă în clasa de bază nu există nici o definire a funcţiei.\n");
206			scanf("%d", &var);
207			if (var == 2)
208			{
209				printf("\nCorect");
210				corect++;
211			}
212			else
213				printf("\nIncorect 2");
214			break;
215		case 17:
216			printf("\n17.Clasele abstracte sunt :");
217			printf("\n1)	a. clasele fără variabile membre;\n");
218			printf("\n2)	b. clasele care nu corespund necesităţilor de modelare ale unei entităţi fizice (reale)\n");
219			printf("\n3)	c. clasele care conţin cel puţin o functie virtuală pură.\n");
220			scanf("%d", &var);
221			if (var == 2)
222			{
223				printf("\nCorect");
224				corect++;
225			}
226			else
227				printf("\nIncorect 2");
228			break;
229		case 18:
230			printf("\n.Operatorul *  din exemplul de mai jos este corect supraîncărcat?\n				class exemplu {					//1\n				int a, b;					//2\n				public:						//3\n				exemplu() {}				//4\n					exemplu(int i, int j) { a = i; b = j; }		//5\n					void arata() { cout << i << ”” << j << ”\n | ; }	//6\n					exemplu operator* (exemplu ex);		//7\n			};						//8\n			exemplu exemplu::operator* (exemplu ex)		//9\n{						//10\n				exemplu tmp;		//11\n					tmp.a = ex.a*a;		//12\n				temp.b = ex.b*b;		//13\n		//14			fie de tipul void.\n			}				//15\n			");
231			printf("\n1)a. da\n");
232			printf("\n2)	b. Nu, greşeala e la linia 14, trebuie return tmp;\n");
233			printf("\n3)c. Nu, greşeala e la liniile 7 şi 9, funcţia trebuie să 	return ex;	\n");
234			scanf("%d", &var);
235			if (var == 2)
236			{
237				printf("\nCorect");
238				corect++;
239			}
240			else
241				printf("\nIncorect 2");
242			break;
243		case 20:
244			printf("\n19.Ce conţine variabila de stare (state) din clasa ios?");
245			printf("\n1)       a. un număr întreg care semnifică numărul de octeţi transmis prin stream la un moment dat;\n");
246			printf("\n2)       b. biţi individuali care specifică modul de desfăşurare a unei operaţii de intrare-ieşire, 	fiecare bit reprezentând câte o eroare posibilă;\n");
247			printf("\n3)       c. biţi individuali care specifică alinierea, formatul de reprezentare, afişare sau nu a bazei, a 		punctului zecimal, forma de afişare (punct fix/forma cu exponent) etc.\n");
248			scanf("%d", &var);
249			if (var == 2 )
250			{
251				printf("\nCorect");
252				corect++;
253			}
254			else
255				printf("\nIncorect 2");
256			break;
257		case 21:
258			printf("\n20.Un manipulator este :");
259			printf("\n1)	a. un operator care modelează un stream şi primeşte ca parametru şi întoarce ca rezultat  adresa stream-ului asupra căruia acţionează;");
260			printf("\n2)	b. o instrucţiune de modificare şi conversie a unor valori de intrare sau de ieşire;");
261			printf("\n3)	c. un operator binar care specifică sensul fluxului şi dispozitivul cu care lucrează.\n");
262			scanf("%d", &var);
263			if (var == 1)
264			{
265				printf("\nCorect");
266				corect++;
267			}
268			else
269				printf("\nIncorect 1");
270			break;
271		case 22:
272			printf("\n21. Care sunt funcţiile API care alcătuiesc o buclă de mesaje?");
273			printf("\n1)	a. SendMessage, GetMessage, DispatchMessage");
274			printf("\n2)	b. DispatchMessage,  PutMessage, CallMessage");
275			printf("\n3)	c. GetMessage, TranslateMessage, DispatchMessage\n");
276			scanf("%d", &var);
277			if (var == 3)
278			{
279				printf("\nCorect");
280				corect++;
281			}
282			else
283				printf("\nIncorect 3");
284			break;
285		case 23:
286			printf("\n22. O interfaţă MDI este :");
287			printf("\n1)	a. o interfaţă având posibilitatea lucrului cu fişiere baze de date");
288			printf("\n2)	b. o interfaţă ce permite lucrul cu mai multe dispozitive fizice (Multi-Device Interface)");
289			printf("\n3)	c. o interfaţă orientată-document ce permite afişarea şi prelucrarea simultană a mai multor fişiere, prin intermediul unor ferestre diferite.\n");
290			scanf("%d", &var);
291			if (var == 3)
292			{
293				printf("\nCorect");
294				corect++;
295			}
296			else
297				printf("\nIncorect 3");
298			break;
299		case 24:
300			printf("\n23. Ce oferă clasa Cdocument?");
301			printf("\n1)	a. facilitatea de a deschide un fişier şi de a afişa datele conţinute");
302			printf("\n2)	b. funcţionalitatea de bază pentru colecţii de date pe care utilizatorul le poate accesa sau salva cu File Open sau File Save");
303			printf("\n3)	c. un editor de documente\n");
304			scanf("%d", &var);
305			if (var == 2)
306			{
307				printf("\nCorect");
308				corect++;
309			}
310			else
311				printf("\nIncorect 2");
312			break;
313		case 25:
314			printf("\n24. Utilizatorul interacţionează cu un document prin intermediul:");
315			printf("\n1)	a. unui control Cedit");
316			printf("\n2)	b. unui obiect de tip Cview ascoiat cu acesta");
317			printf("\n3)	c. unei clase Cwind0\n");
318			scanf("%d", &var);
319			if (var == 2)
320			{
321				printf("\nCorect");
322				corect++;
323			}
324			else
325				printf("\nIncorect 2");
326			break;
327		case 26:
328			printf("\n25. Incărcătorul de clase (class loader) serveşte pentru:");
329			printf("\n1)	a. verificarea corectitudinii sintaxei unei clase");
330			printf("\n2)	b. verificarea codului-octet");
331			printf("\n3)	c. incărcarea unei clase de către o subclasă a sa\n");
332			scanf("%d", &var);
333			if (var == 2)
334			{
335				printf("\nCorect");
336				corect++;
337			}
338			else
339				printf("\nIncorect 2");
340			break;
341		case 27:
342			printf("\n26. Ce sunt variabilele instanţă?");
343			printf("\n1)	a. variabilele membre de tip public");
344			printf("\n2)	b. variabilele oarecare");
345			printf("\n3)	c. variabilele membre ale unei clase, care nu sunt de tip static\n");
346			scanf("%d", &var);
347			if (var == 3)
348			{
349				printf("\nCorect");
350				corect++;
351			}
352			else
353				printf("\nIncorect 3");
354			break;
355		case 28:
356			printf("\n27. Ce inseamnă /**   */?");
357			printf("\n1)	a. sintaxă eronată");
358			printf("\n2)	b. comentarii pe un rând");
359			printf("\n3)	c. comentarii pe mai multe linii, care sunt extrase automat din codul-sursă de către generatorul de documentaţie\n");
360			scanf("%d", &var);
361			if (var == 3)
362			{
363				printf("\nCorect");
364				corect++;
365			}
366			else
367				printf("\nIncorect 3");
368			break;
369		case 29:
370			printf("\n28. Care este valoarea implicită a tipului referinţă?");
371			printf("\n1)	a. valoarea null care indică o referinţă încă neprecizată");
372			printf("\n2)	b. valoarea False");
373			printf("\n3)	c. valoarea 0(zero)\n");
374			scanf("%d", &var);
375			if (var == 1)
376			{
377				printf("\nCorect");
378				corect++;
379			}
380			else
381				printf("\nIncorect 1");
382			break;
383		case 30:
384			printf("\n29. Instrucţiunea break produce:");
385			printf("\n1)	a. intreruperea execuţiei programului până când utilizatorul apasă Enter");
386			printf("\n2)	b. „scurtcircuitarea” unei bucle (for,do,while) – adică salt peste instrucţiunile de până la sfârşitul buclei");
387			printf("\n3)	c. intreruprea unei bucle (for,do,while) sau a unui bloc switch\n");
388			scanf("%d", &var);
389			if (var == 3)
390			{
391				printf("\nCorect");
392				corect++;
393			}
394			else
395				printf("\nIncorect 3 ");
396			break;
397		case 31:
398			printf("\n. Care va fi efectul secvenţei următoare_\n do{ \n		car_citit = (char)System.in.read();   \n			rel(car_citit);			\n		}					\n			while (car_citit != ’T’);\n				");
399			printf("\n1)a.se prelucrează toate caracterele tastate până   când se apasă T; acesta nu va fi prelucrat");
400			printf("\n2)b.se ignoră toate caracterele diferite de T");
401			printf("\n3)c.se prelucrează toate caracterele testate până      se apasă T; acesta va fi de asemenea prel.\n");
402			scanf("%d", &var);
403			if (var == 3)
404			{
405				printf("\nCorect");
406				corect++;
407			}
408			else
409				printf("\nIncorect 3");
410			break;
411		case 32:
412			printf("\n31. Instanţierea unui obiect se face prin:");
413			printf("\n1)	a. declararea obiectului");
414			printf("\n2)	b. operatorul new");
415			printf("\n3)	c. declarare şi atribuire\n");
416			scanf("%d", &var);
417			if (var == 3)
418			{
419				printf("\nCorect");
420				corect++;
421			}
422			else
423				printf("\nIncorect 3");
424			break;
425		case 33:
426			printf("\n. În fragmentul următor de program sintaxa liniei marcate este:\n				public class Biblio {\n				private nr_carti;\n				public Biblio(int nr_init)		\n				{ nr_carti = nr_init; }\n					public int CiteCarti()		\n				{ return nr_carti; }\n					…\n			}\n			…\n			Int carti_in_biblio = new Biblio(100).CateCarti();   //marcaj\n			");
427			printf("\n1)a.validă ");
428			printf("\n2)o/o	b.nu este validă ");
429			printf("\n3)c.ambiguă\n");
430			scanf("%d", &var);
431			if (var == 1)
432			{
433				printf("\nCorect");
434				corect++;
435			}
436			else
437				printf("\nIncorect 1");
438
439			break;
440		case 34:
441			printf("\n33. Cum putem afişa ceva pe ecran în cadrul unei miniaplicaţii?");
442			printf("\n1)	a. scriem în metoda init() secvenţa \npublic void init(Thread th){\n th.drawstring(“textul de afisat”);\n}\n");
443			printf("\n2)	b. scriem în metoda repaint() secvenţa System.out.println(”textul de afişat”);");
444			printf("\n3)c. suprascriem metoda paint() astfel:\n  public void paint(Graphics gr){\n gr.drawstring(“textul de afisat”);\n } \n ");
445			scanf("%d", &var);
446			if (var == 3)
447			{
448				printf("\nCorect");
449				corect++;
450			}
451			else
452				printf("\nIncorect 3");
453			break;
454		case 35:
455			printf("\n34. Activităţile aferente precizării structurii statice în cadrul metodei Civello şi Mitchell au ca scop:");
456			printf("\n1)	a. precizarea structurii programului(module, funcţii, fişiere, clase, obiecte)");
457			printf("\n2)	b. definirea claselor şi a relaţiilor dintre ele(comunicaţia între clase, clasificări, atribuiri)");
458			printf("\n3)	c. definirea ierarhiilor de clase(moştenirea, polimorfism, supraîncărcarea, constructori, destructori).");
459			scanf("%d", &var);
460			if (var == 2)
461			{
462				printf("\nCorect");
463				corect++;
464			}
465			else
466				printf("\nIncorect 2");
467			break;
468		case 36:
469			printf("\n35. Pentru un produs-program, pot fi distinse următoarele nivele generale de abstractizare:");
470			printf("\n1)	a. variabile de instanţă, instanţierea claselor generice, moştenire, mesaje");
471			printf("\n2)	b. domeniul problemei,utilizator, gestiunea fişierelor, gestiunea proceselor, structuri de date fundamentale, interfaţa cu perifericele");
472			printf("\n3)	c. nivelul logic, nivelul comunicaţiei, nivelul driver, nivelul fizic, nivelul aplicaţiei, nivelul interfeţei utilizator\n");
473			scanf("%d", &var);
474			if (var == 2)
475			{
476				printf("\nCorect");
477				corect++;
478			}
479			else
480				printf("\nIncorect 2");
481			break;
482		case 37:
483			printf("\n36.Java permite realizarea programarii concurente prin:");
484			printf("\n1) 	 a)...  ");
485			printf("\n2) b)... ");
486			printf("\n3) c)folosirea firelor de executie si sincronizarea metodelor\n");
487			scanf("%d", &var);
488			if (var == 3)
489			{
490				printf("\nCorect");
491				corect++;
492			}
493			else
494				printf("\nIncorect 3");
495			break;
496		case 38:
497			printf("\n37.principalele biblioteci de clase Java sunt orientate pe ");
498			printf("\n1) a)pe GUI, imagini si audio, lucrul in retea ");
499			printf("\n2) b)TCP/IP, FTP  ");
500			printf("\n3) 	 c)interfata cu utilizatorul, interfata de retea,interfata cu  baza de date\n");
501			scanf("%d", &var);
502			if (var == 1)
503			{
504				printf("\nCorect");
505				corect++;
506			}
507			else
508				printf("\nIncorect 1");
509			break;
510		case 39:
511			printf("\n38.secventa de program Java de mai jos\n	public class Apartament {   		//1\n				private:    				//2\n					int nr_cam;  			 //3\n					int supraf; 			  //4\n				public:   				 //\n					Apartament(int nrc, int sup)             //6\n{\n						nr_cam = nrc; supraf = sup;\n					}        //7\n					...\n			};      					//8\n	");
512			printf("\n1)  a)este corecta");
513			printf("\n2)  b)este eronata, trebuie private in liniile 3 si 4, public in linia 6, toate fara : si in linia 8 nu trebuie ;");
514			printf("\n3)  c)...\n");
515			scanf("%d", &var);
516			if (var == 2)
517			{
518				printf("\nCorect");
519				corect++;
520			}
521			else
522				printf("\nIncorect 2");
523			break;
524		case 40:
525			printf("\n39.ce semnifica sintaxa de la linia marcata ?\n				public class Biblioteca {\n				public Biblioteca() { this(0); }   //marcaj\n				public Biblioteca(int nrc\n				{ \n					nr_crt = private nr_crt;    //aici am observat ca lipseste tipul campului !? \n					...\n				}\n				");
526			printf("\n1)  a)este un constructor care pune pe zero obiectul curent");
527			printf("\n2) 	  b)este o metoda speciala care genereaza o referinta la obiectul  curent ");
528			printf("\n3)  	  c) este un constructor care initializeaza cu o valoare  redefinita (aici , zero) variabila instanta, prin apelul celuilalt  constructor, inlocuind astfel conventia cu argumente implicite,  care nu este disponibila in Java.\n");
529			scanf("%d", &var);
530			if (var == 3)
531			{
532				printf("\nCorect");
533				corect++;
534			}
535			else
536				printf("\nIncorect 3");
537			break;
538		case 41:
539			printf("\n40.* Ce sunt variabilele de tip instanta in Java? ");
540			printf("\n1) a)variabile membre de tip public ");
541			printf("\n2 	 b)variabile oarecare  ");
542			printf("\n3) c)variabilele membre ale unei clase, care nu sunt de tip static \n");
543			scanf("%d", &var);
544			if (var == 3)
545			{
546				printf("\nCorect");
547				corect++;
548			}
549			else
550				printf("\nIncorect 3");
551			break;
552		case 42:
553			printf("\n41.Graphics este in Java :");
554			printf("\n1)a)o variabila membra a java.applet.Applet care permite apelarea  operatiilor de intrare/iesire  ");
555			printf("\n2)b)un tip predefinit care contine mai multe metode pentru  desenarea imaginilor si scrierea textului pe ecran  ");
556			printf("\n3)c)denumirea engleza a aspectelor grafice ale miniaplicatiilor  Java\n");
557			scanf("%d", &var);
558			if (var == 2)
559			{
560				printf("\nCorect");
561				corect++;
562			}
563			else
564				printf("\nIncorect 2");
565			break;
566		case 43:
567			printf("\n42.Prin mostenire intelegem:");
568			printf("\n1)a) separarea aspectelor externe ale unui obiect,accesibile altor obiecte,de cele interne.");
569			printf("\n2)b) ca aceeasi metoda poate avea comportament diferit in clase diferite.");
570			printf("\n3)c) transmiterea atributelor si operatiilor de-a lungul claselor bazate pe o relatie ierarhica.\n");
571			scanf("%d", &var);
572			if (var == 3)
573			{
574				printf("\nCorect");
575				corect++;
576			}
577			else
578				printf("\nIncorect 3");
579			break;
580		case 44:
581			printf("\n43.In lipsa specificatorilor „public” si „private” toti membrii unei clase vor fi implicit:");
582			printf("\n1)	a) privati");
583			printf("\n2)	b) compilatorul va semnala eroare");
584			printf("\n3)	c) publici\n");
585			scanf("%d", &var);
586			if (var == 1)
587			{
588				printf("\nCorect");
589				corect++;
590			}
591			else
592				printf("\nIncorect 1");
593			break;
594		case 45:
595			printf("\n44.O functie virtuala:");
596			printf("\n1)	a) defineste o metoda care nu poate fi apelata din clasa derivata chiar daca este publica.");
597			printf("\n2)	b) defineste o clasa generala de actiuni iar redefinirea ei introduce o metoda specifica.");
598			printf("\n3)	c) defineste o metoda specifica iar redefinirea ei introduce o clasa generala de actiuni.\n");
599			scanf("%d", &var);
600			if (var == 2)
601			{
602				printf("\nCorect");
603				corect++;
604			}
605			else
606				printf("\nIncorect 2");
607			break;
608		case 46:
609			printf("\n45. Fie urmatoarea secventa de program:\n				Class A\n			{ \n				...\n				Public:  int adunare(int x,int y)\n			{ \n				...\n			}\n			};\n			Class B : public A\n			{ \n				...\n				Public:  float adunare(float x,float y)\n			{ \n				...\n			}\n			};\n			Daca avem un obiect : B ob(de tipul lui B) atunci B.adunare(3, 4) va apela : \n			");
610			printf("\n1)a)	Va genera eroare deoarece B este o clasa si nu un obiect");
611			printf("\n2)b)	 Functia adunare din clasa B");
612			printf("\n3)c)	 Functia adunare din clasa A\n");
613			scanf("%d", &var);
614			if (var == 1)
615			{
616				printf("\nCorect");
617				corect++;
618			}
619			else
620				printf("\nIncorect 1 ");
621			break;
622		case 47:
623			printf("\n46. Programul urmator are ca efect:\n #include<iostream.h>\n				Class exemplu_static{ \n				Static int a;	//aici e o variabila membra de tip static\n			Int b;		// aceasta nu e de tip static\n		Public:\n			Void seteaza(int i,int j) { a = i; b = j; }\n			Void arata();\n			};\n			Int exemplu_static::a; 	// iata si definirea globala\n									// pentru variabila de tip static\n			Void exemplu_static::arata()\n			{ \n				Cout << ”acesta este a static: „ << a;\n				Cout << ”\nacesta este b ne - static: „ << b;\n				Cout << ”\n”;\n			}\n			Main()\n			{ \n				Exemplu_static ob1, ob2;	//doua obiecte de tipul clasei\nOb1.seteaza(1, 2);\n				Ob1.arata();\n				Ob2.seteaza(3, 4);\n				Ob2.arata();\n				Ob1.arata();\nReturn 0;\n}\nAfisarea urmatoarelor texte : \n");
624			printf("\n1)a)	Acesta este a static: 1   \n         				Acesta este b ne - static: 2   \n				Acesta este a static: 1	       \n				Acesta este b ne - static : 4	   \n				Acesta este a static: 1	          \n				Acesta este b ne - static : 2	   \n	");
625			printf("\n2)b)	Acesta este a static: 1\n				Acesta este b ne - static: 2\n				Acesta este a static: 3\n				Acesta este b ne - static : 4\n				Acesta este a static: 3\n			Acesta este b ne - static : 2\n	");
626			printf("\n3)1              c)  acesta este a static: 1\n				             acesta este b ne - static : 2\n					            acesta este a static: 1\n				            acesta este b ne - static : 4\n			            acesta este a static: 3\n					            acesta este b ne - static : 2\n\n");
627			scanf("%d", &var);
628			if (var == 2)
629			{
630				printf("\nCorect");
631				corect++;
632			}
633			else
634				printf("\nIncorect 2");
635			break;
636		case 48:
637			printf("\n47. Daca avem o clasa student si constructorul acesteia de forma student( char *x,int y); atunci un obiect initializat se va declara:");
638			printf("\n1)	a) student a();");
639			printf("\n2)	b) student a(„Ion”,4);");
640			printf("\n3)	c)  student („Ion”,4);\n");
641			scanf("%d", &var);
642			if (var == 2)
643			{
644				printf("\nCorect");
645				corect++;
646			}
647			else
648				printf("\nIncorect 2");
649			break;
650		case 49:
651			printf("\nAvand secventa de program:\n				Class aaa\n			{ \n				Int x;\n			...\n				Public\n			...\n			};\n			...\n				aaa ob\n			cout << ob.x;\n			");
652			printf("\n1)a)	Secventa este corecta");
653			printf("\n2)b)	Secventa de cod nu este corecta deoarece trebuia scris cout<<x;");
654			printf("\n3)c)	Secventa de cod nu este corecta,deoarece nu avem acces la membrii privati ai unei clase.\n");
655			scanf("%d", &var);
656			if (var == 3)
657			{
658				printf("\nCorect");
659				corect++;
660			}
661			else
662				printf("\nIncorect 3");
663			break;
664		case 50:
665			printf("\n49. Secventa urmatoare de program:\n#include<iostream.h>\n				Class ordine{ \n			Public\nInt cine;\n				Ordine(int);\n				~ordine();\n			} glob_ob1(10), glob_ob2(20); 	// doua obiecte globale\n			ordine::ordine(int valinit)\n			{ \n				Cout << ”Initializare „ << valinit << ”\n”;\n				Cine = valinit;\n			}\n			Ordine::~ordine()\n			{ \n				Cout << ”distrugere „ << cine << ”\n”;\n			}\n			Main()\n			{ \n				Ordine local_ob1(30);	// obiect local\n				Cout << ”Vedeti ? Aceasta nu e prima linie afisata!\n”;\n				Ordine local_ob2(40);	//alt obiect local\n				Return 0;\n			}\n			Va determina afisarea urmatoarelor texte \n				");
666			printf("\n1)a)	Initializare 10\n				Initializare 20\n				Initializare 30\n				Initializare 40\n				Vedeti ? Aceasta nu e prima linie afisata!\n				Distrugere 40\n				Distrugere 30\n				Distrugere 20\n				Distrugere 10\n				");
667			printf("\n2)b)	Initializare 10\n				Initializare 20\n				Initializare 30\n				Vedeti ? Aceasta nu e prima linie afisata!\n				Initializare 40\n				Distrugere 40\n				Distrugere 30\n				Distrugere 20\n				Distrugere 10\n				");
668			printf("\n3)c)	Initializare 10\n				Initializare 20\n				Initializare 30\n				Vedeti ? Aceasta nu e prima linie afisata!\n				Initializare 40\n				Distrugere 10\n				Distrugere 20\n				Distrugere 30\n				Distrugere 40\n				\n");
669			scanf("%d", &var);
670			if (var == 2)
671			{
672				printf("\nCorect");
673				corect++;
674			}
675			else
676				printf("\nIncorect 2");
677			break;
678		case 51:
679			printf("\n50. Fie urmatoarea secventa de program:\n				Class A\n			{ \n				...\n				Public: \n			Int functie(int x,int y)\n			{ \n				...\n			}\n			};\n			Class B : public A\n			{ \n				...\n				Public: \n			...\n			};\n			Daca avem un obiect : B ob(de tipul lui B) atunci ob.functie(5, 8) : \n				");
680			printf("\n1)a)	Va apela functia din clasa A deoarece clasa B mosteneste public clasa A");
681			printf("\n2)b)	Va genera eroare deoarece in clasa B nu exista functia adunare.");
682			printf("\n3)c)	Va genera eroare deoarece clasa B nu are acces la functiile membre ale clasei A\n");
683			scanf("%d", &var);
684			if (var == 1)
685			{
686				printf("\nCorect");
687				corect++;
688			}
689			else
690				printf("\nIncorect 1");
691			break;
692		case 52:
693			printf("\n51. O clasa poate avea:");
694			printf("\n1)	a) un singur constructor si un singur destructor.");
695			printf("\n2)	b) mai multi constructori si un singur destructor.");
696			printf("\n3)	c) mai multi constructori si destructori.\n");
697			scanf("%d", &var);
698			if (var == 2)
699			{
700				printf("\nCorect");
701				corect++;
702			}
703			else
704				printf("\nIncorect 2");
705			break;
706		case 53:
707			printf("\n52. Care din urmatoarele afirmatii este falsa?");
708			printf("\n1)	a) constructorul nu poate fi virtual,destructorul poate fi.");
709			printf("\n2)	b) functiile virtuale nu pot fi membri statici ai clasei.");
710			printf("\n3)	c) functiile virtuale pot fi membri friend ai clasei.\n");
711			scanf("%d", &var);
712			if (var == 3)
713			{
714				printf("\nCorect");
715				corect++;
716			}
717			else
718				printf("\nIncorect 3");
719			break;
720		case 54:
721			printf("\n53. Un constructor poate returna:");
722			printf("\n1)	a) numai tipuri de date predefinite in C sau C++.");
723			printf("\n2)	b) nu poate returna o valoare.");
724			printf("\n3)	c) tipuri de date definite de programatori sau tipuri de date predefinite in C sau C++.\n");
725			scanf("%d", &var);
726			if (var == 2)
727			{
728				printf("\nCorect");
729				corect++;
730			}
731			else 
732				printf("\nIncorect 2");
733			break;
734		case 55:
735			printf("\n54. Daca o clasa de baza este mostenita private, toti membrii publici ai clasei devin in clasa derivata membri:");
736			printf("\n1)	a) publici");
737			printf("\n2)	b) privati");
738			printf("\n3)	c) protejati\n");
739			scanf("%d", &var);
740			if (var == 2)
741			{
742				printf("\nCorect");
743				corect++;
744			}
745			else
746				printf("\nIncorect 2");
747			break;
748		case 56:
749			printf("\n55. Secventa urmatoare de program:\n #include<iostream.h>			//1\n				Class un_param{				//2\n				Int a;				//3\n		Public:					//4\n			Un_param(int i);			//5\n			Int da_a() { return a; }		//6\n			};					//7\n			Main()					//8\n			{\n				Un_param obiect = 55;		//9   paseaza 55 lui i din constructor si \n				Cout << obiect.da_a();		//10 afiseaza ca sa ne convingem ca asa e\n				Return 0;			//11\n			}					//12\n			Va da eroare de compilare deoarece : \n");
750			printf("\n1)a)	Linia 7 are „;” dupa acolada");
751			printf("\n2)b)	Linia 9 trebuie sa arate corect asa: un_param obiect(55)");
752			printf("\n3)c)	Constructorul nu e definit (trebuia: un_param(int i){a=i;})	\n");
753			scanf("%d", &var);
754			if (var == 3)
755			{
756				printf("\nCorect");
757				corect++;
758			}
759			else
760				printf("\nIncorect 3");
761			break;
762		case 57:
763			printf("\n56. O clasa care contine o functie virtuala se numeste:");
764			printf("\n1)	a) clasa polimorfica");
765			printf("\n2)	b) clasa incapsulata");
766			printf("\n3)	c) clasa virtuala\n");
767			scanf("%d", &var);
768			if (var == 12)
769			{
770				printf("\nCorect");
771				corect++;
772			}
773			else
774				printf("\nIncorect 1");
775			break;
776		case 58:
777			printf("\n. Precizati varianta corecta de creare a unui tablou de obiecte de tipul A. Fie:\n				Class A\n			{ \n			Public: \n				...\n			};\n			A obiect;\n			Pentru a crea un tablou de obiecte trebuie facut : \n			");
778			printf("\n1)a)	Tablou A(10);");
779			printf("\n2)b)	Tablou A[10];");
780			printf("\n3)c)	A tablou[10];\n");
781			scanf("%d", &var);
782			if (var == 3)
783			{
784				printf("\nCorect");
785				corect++;
786			}
787			else
788				printf("\nIncorect 3");
789			break;
790		case 59:
791			printf("\n58. In cadrul unei clase se defineste o variabila membru statica.Atunci:");
792			printf("\n1)a) pentru fiecare instantiere a clasei avem cate o variabila membru statica.");
793			printf("\n2)b) pentru toate instantierile clasei avem o singura variabila membru statica.");
794			printf("\n3)c) o clasa nu poate fi instantiata mai mult decat o data daca avem declarat in cadrul ei o variabila membru statica.\n");
795			scanf("%d", &var);
796			if (var == 2)
797			{
798				printf("\nCorect");
799				corect++;
800			}
801			else
802				printf("\nIncorect 2");
803			break;
804		case 60:
805			printf("\n59. Care este avantajul folosirii clasei Carray?");
806			printf("\n1)	a) poate accesa liste foarte lungi");
807			printf("\n2)	b) permite verificarea domeniului la accesarea unui tablou");
808			printf("\n3)	c) permite ordonarea rapida a unei liste\n");
809			scanf("%d", &var);
810			if (var == 2)
811			{
812				printf("\nCorect");
813				corect++;
814			}
815			else
816				printf("\nIncorect 2");
817			break;
818		case 61:
819			printf("\n60. Ce este biblioteca de tipare standard?");
820			printf("\n1)	a) un set de colectii,algoritmi si functii generale care utilizeaza masiv tiparele pentru functiile si clasele sale.");
821			printf("\n2)	b) un sistem grafic de preincarcare a unei imagini standardizate pentru fisiere bitmap.");
822			printf("\n3)	c) o biblioteca cu tipare de functii matematice standardizate.\n");
823			scanf("%d", &var);
824			if (var == 1)
825			{
826				printf("\nCorect");
827				corect++;
828			}
829			else
830				printf("\nIncorect 1");
831			break;
832		case 62:
833			printf("\n61. Un container serveste pentru:");
834			printf("\n1)	a) stocarea mai multor tablouri de valori");
835			printf("\n2)	b) maparea evenimentelor la obiecte");
836			printf("\n3)	c) stocarea obiectelor\n");
837			scanf("%d", &var);
838			if (var == 3)
839			{
840				printf("\nCorect");
841				corect++;
842			}
843			else
844				printf("\nIncorect 3");
845			break;
846		case 63:
847			printf("\n. In ce ordine se vor afisa numerele de catre programul urmator?\n#include<stdafx.h>\n#include<iostream.h>\n#include<vector>\n#include<algorithm>\n				Using namespace std;\n			Typedef vector<int> vectsort;\n			Int main(int argc, char *argv[])\n			{ \n				Vectsort v;\n				v.push_back(434);\n				v.push_back(356);\n				v.push_back(267);\n				v.push_back(987);\n				sort(v.begin(), v.end());\n				vector<int>::reverse_iterator iter = v.rbegin();\n				while (iter != v.rend())\n				{ \n					Cout << *iter << endl;\n					++iter;\n				}\n				Return 0;\n			}\n");
848			printf("\n1)a)	434,356,267,987");
849			printf("\n2)b)	267,356,434,987");
850			printf("\n3)c)	987,434,356,267\n");
851			scanf("%d", &var);
852			if (var == 3)
853			{
854				printf("\nCorect");
855				corect++;
856			}
857			else
858				printf("\nIncorect 3");
859			break;
860		case 64:
861			printf("\n62. Pentru o colectie de tip harta,mecanismul de regasire a informatiei este:");
862			printf("\n1)	a) fiecarui articol stocat intr-o harta ii este asociata o cheie unica,fiecare cheie este convertita mai intai intr-o valoare codificata (hash value), care este folosita apoi pentru a cauta articolul dorit dintr-o lista.");
863			printf("\n2)b) fiecarui articol stocat intr-o harta ii este asociata o cheie unica,fiecare cheie este convertita mai intai intr-o valoare codificata (hash value), care este folosita apoica indice intr - o matrice unde sunt stocate articolele din colectie				");
864			printf("\n3)d)	exista o harta a memoriei (memory map) unde fiecarui articol ii corespunde un indice unic numit hash index, prin accesarea cu hash index se determina selectia automata a articolului dorit.\n");
865			scanf("%d", &var);
866			if (var == 2)
867			{
868				printf("\nCorect");
869				corect++;
870			}
871			else
872				printf("\nIncorect 2");
873			break;
874		case 65:
875			printf("\n63. Iteratorii se folosesc pentru:");
876			printf("\n1)	a) indicarea evolutiei calculelor in cadrul unor iteratii din algoritmii recursivi");
877			printf("\n2)	b) numararea elementelor dintr-un container");
878			printf("\n3)	c) deplasarea printre articolele stocate intr-un container.\n");
879			scanf("%d", &var);
880			if (var == 3)
881			{
882				printf("\nCorect");
883				corect++;
884			}
885			else
886				printf("\nIncorect 3");
887			break;
888		case 66:
889			printf("\n64. Cum e corect?");
890			printf("\n1)a) \n				template<class T> \n			class CStack \n			{ \n			Public: \n				Cstack(); \n				Virtual ~Cstack(); \n				BOOL IsEmpty()const; \n				T  Pop(); \n				Void Push(const T&item); \n			Private: \n				CStack <T>(const CStack &T) {}; \n				... \n");
891			printf("\n2)b) \n				template<int T> \n			class CStack \n			{ \n			Public \n				Cstack(); \n				Virtual  ~Cstack(); \n				BOOL IsEmpty()const; \n				T  Pop(); \n				Void Push(const T&item); \n			Private: \n				CStack <T>(const CStack &T) {}; \n				... \n					");
892			printf("\n3)c)\n				typedef  template<int T>\n				class CStack\n			{ \n			Public: \n				Cstack();\n				Virtual  ~Cstack();\n				BOOL IsEmpty()const;\n				T  Pop();\n				Void Push(const T&item);\n			Private: \n				CStack <T>(const CStack &T) {};\n				...\n");
893			scanf("%d", &var);
894			if (var == 1)
895			{
896				printf("\nCorect");
897				corect++;
898			}
899			else
900				printf("\nIncorect 1");
901			break;
902		case 67:
903			printf("\n65. Tiparele de programare au avantajul ca permit:");
904			printf("\n1)	a) definire de clase care pot fi usor reutilizate prin mostenire");
905			printf("\n2	b) utilizarea de clase si functii care accepta parametri la folosire");
906			printf("\n3)	c) apeluri simple pentru transferul parametrilor actuali\n");
907			scanf("%d", &var);
908			if (var == 2)
909			{
910				printf("\nCorect");
911				corect++;
912			}
913			else
914				printf("\nIncorect 2");
915			break;
916		case 68:
917			printf("\n	66. In codul sursa de mai jos instructia marcata cu $ este:\n				...\n				Class cladire{ \n			Int camere;\n			Int etaje;\n		Public: \n			Void nr_camere(int);\n			Int cate_camere();\n			Void nr_etaje(int);\n			Int cate_etaje();\n			};\n			Class apartament : public cladire{ \n				Int dormitoare;\n		Public: \n			Void nr_dormitoare(int);\n			Int cate_dormitoare();\n			};\n			...\n				Main()\n			{\n				Apartament ap;\n				Ap.nr_dormitoare(2);\n				Ap.nr_camere(5);		// $\n				...\n");
918			printf("\n1)a)	corecta daca cuvantul-cheie public de la clasa apartament e schimbat in private");
919			printf("\n2)b)	incorecta");
920			printf("\n3)c)	valida\n");
921			scanf("%d", &var);
922			if (var == 3)
923			{
924				printf("\nCorect");
925				corect++;
926			}
927			else
928				printf("\nIncorect 3");
929			break;
930		case 69:
931			printf("\n67. Executabilul generat de un mediu de dezvoltare pentru sisteme incorporate ruleaza:");
932			printf("\n1)	a) pe microcontrollerul incorporat din sistemul gazda (host)");
933			printf("\n2)	b) pe calculatorul pe care ruleaza mediul de dezvoltare");
934			printf("\n3)	c) pe microcontrollerul din sistemul incorporat\n");
935				printf("\n la asta nu e sigur raspunsul\n");
936			scanf("%d", &var);
937			if (var == 3)
938			{
939				printf("\nCorect");
940				corect++;
941			}
942			else
943				printf("\nIncorect 3");
944			break;
945		case 70:
946			printf("\n69. Pentru a implementa arhitectura document-view intr-o aplicatie MFC,pentru partea de document:");
947			printf("\n1)	a) Se deriveaza o clasa din Cdocument pentru fiecare tip de document,se adauga variabile membre pentru a stoca fiecare data document,se implementeaza functii membre pentru citirea si modificarea datelor document si se suprascrie functia membra Cobject::On-Update pentru a actualiza datele de pe disc.");
948			printf("\n2)	b) Se deriveaza o clasa din Cdocument pentru fiecare tip de document,se adauga variabile membre pentru a stoca fiecare data document,se implementeaza functii membre pentru citirea si modificarea datelor document si se suprascrie functia membra Cobject::Serialize in clasa document pentru a scrie si citi date document pe si de pe disc.");
949			printf("\n3)	c) Se deriveaza o clasa din Cdocument pentru fiecare tip de document,se adauga variabile membre pentru a stoca fiecare data document,se implementeaza functia UpdateAllViews pentru actualizarea tuturor vizualizarilor si se suprascrie functia membra Cobject::Serialize in clasa document pentru a scrie si citi date document pe si de pe disc.\n");
950			scanf("%d", &var);
951			if (var == 2)
952			{
953				printf("\nCorect");
954				corect++;
955			}
956			else
957				printf("\nIncorect 2");
958			break;
959		case 71:
960			printf("\n70. Mecanismul de actualizare a tuturor vizualizarilor in cadrul arhitecturii document-view presupune:");
961			printf("\n1)	a) Modificarea documentului prin accesul din cadrul vizualizarii la metoda de modificare a variabilei membre din clasa derivata din CDocument,apelul metodei UpdateAllViews din acea clasa,care trimite notificari catre toate vizualizarile active si suprascrierea metodelor OnDraw (de desenare) din clasele de vizualizare,pentru a implementa actualizarile dorite pe aceste vizualizari.");
962			printf("\n2)	b) Modificarea documentului prin accesul din cadrul vizualizarii la metoda de modificare a variabilei membre din clasa derivata din CDocument,apelul metodei UpdateAllViews din acea clasa,care trimite notificari catre toate vizualizarile active si suprascrierea metodelor OnUpdate din clasele de vizualizare,pentru a implementa actualizarile dorite pe aceste vizualizari.");
963			printf("\n3)	c) Modificarea documentului prin accesul din cadrul vizualizarii la metoda de serializare a variabilei membre din clasa derivata din CDocument,apelul metodei UpdateAllViews din acea clasa,care trimite notificari catre toate vizualizarile active si suprascrierea metodelor OnRedraw (de redesenare) din clasele de vizualizare,pentru a implementa actualizarile dorite pe aceste vizualizari.\n");
964			scanf("%d", &var);
965			if (var == 2)
966			{
967				printf("\nCorect");
968				corect++;
969			}
970			else
971				printf("\nIncorect 2");
972			break;
973		case 72:
974			printf("\n71. Modelarea orientata pe obiecte parcurge urmatoarele etape:");
975			printf("\n1)	a) definirea claselor si a relatiilor dintre ele (comunicatia intre clase,clasificari, atribute)");
976			printf("\n2)	b) analiza a ceea ce face sistemul sa functioneze, examinarea domeniului problemei, utilizarea entitatilor si relatiilor dintre acestea pentru a concepe arhitectura aplicatiei.");
977			printf("\n3)	c) analiza a ceea ce face sistemul, determinarea functiunilor necesare prin descompunerea problemei in altele mai mici, determinarea claselor si a relatiior dintre acestea.\n");
978			scanf("%d", &var);
979			if (var == 2)
980			{
981				printf("\nCorect");
982				corect++;
983			}
984			else
985				printf("\nIncorect 2");
986			break;
987		case 73:
988			printf("\n72. In cadrul modelarii orientate pe obiecte, avem urmtoarele avantaje fata de abordarea structurata:");
989			printf("\n1)	a) este mai bine deoarece programul este vazut ca un model al realitatii, fiind format din obiecte care interactioneaza actiunile intreprinse in program se fac de catre obiecte si cu ajutorul lor.");
990			printf("\n2)	b) entitatile sunt mai stabile decat functiile, intretinerea aplicatiei este mai usoara, componentele de program sunt mai usor reutilizabile si tranzitia de la analiza la proiectare si implementare este naturala.");
991			printf("\n3)	c) etapele de dezvoltare sunt mai coerente deoarece se incepe cu ceea ce face sistemul sa functioneze, apoi se examineaza domeniul problemei,pentru a gasi entitati care au limite( frontiere) fizice sau conceptuale care le separa de restul domeniului si se utilizeaza entitatile si relatiile dintre acestea pentru a concepe arhitectura aplicatiei.\n");
992			scanf("%d", &var);
993			if (var == 2)
994			{
995				printf("\nCorect");
996				corect++;
997			}
998			else
999				printf("\nIncorect 2");
1000			break;
1001		case 74:
1002			printf("\n73. Analiza orientata pe obiecte este:");
1003			printf("\n1)	a) analiza solutiilor posibile prin inventarea (conceperea) sau alegerea claselor de obiecte pentru domeniul solutiilor si stabilirea relatiilor logice si interactiunilor dintre ele.");
1004			printf("\n2)	b) descoperirea obiectelor esentiale (key objects) la nivelul curent de abstractizare si transferarea responsabilitatilor sistemului catre obiecte.");
1005			printf("\n3)	c) procesul de identificare si definire a claselor (obiectelor) ce apartin domeniului problemei.\n");
1006			scanf("%d", &var);
1007			if (var == 3)
1008			{
1009				printf("\nCorect");
1010				corect++;
1011			}
1012			else
1013				printf("\nIncorect 3");
1014			break;
1015		case 75:
1016			printf("\n74. In UML mesajul este:");
1017			printf("\n1)	a) abstractie a unei unitati de comunicare intre un obiect sursa si un obiect tinta( cel care receptioneaza mesajul)");
1018			printf("\n2)	b) un apel CallAction");
1019			printf("\n3)	c) trimiterea unui semnal de la un obiect sursa la un obiect tinta (cel care receptioneaza mesajul).\n");
1020			scanf("%d", &var);
1021			if (var == 1)
1022			{
1023				printf("\nCorect");
1024				corect++;
1025			}
1026			else
1027				printf("\nIncorect 1");
1028			break;
1029		case 76:
1030			printf("\n75. Relatiile dintre clase si obiecte sunt de tipul:");
1031			printf("\n1)	a) colaborare, extensie, specializare, principiul de susbstitutie al lui Liskov");
1032			printf("\n2)	b) asociere, agregare, compozitie, generalizare, dependenta");
1033			printf("\n3)	c) parte/intreg, catalog, fizic,tip mesaj, compozitie, dependenta,generalizare.\n");
1034			scanf("%d", &var);
1035			if (var == 2)
1036			{
1037				printf("\nCorect");
1038				corect++;
1039			}
1040			else
1041				printf("\nIncorect 2");
1042			break;
1043		case 77:
1044			printf("\n76. Cerintele functionale in UML");
1045			printf("\n1)	a) sunt codificate prin note text");
1046			printf("\n2)	b) sunt reprezentate direct de cazurile de utilizare");
1047			printf("\n3)	c) sunt reprezentate prin diagrame de secventa si prin diagrame de stare. \n");
1048			scanf("%d", &var);
1049			if (var == 3)
1050			{
1051				printf("\nCorect");
1052				corect++;
1053			}
1054			else
1055				printf("\nIncorect 3");
1056			break;
1057		case 78:
1058			printf("\n77. Un caz de utilizare este:");
1059			printf("\n1)	a) o capabilitate nominalizata a unei entitati structurale in cadrul unui model.");
1060			printf("\n2)	b) un obiect in afara scopului sistemului considerat dar care are interactiuni semnificative cu acesta prin cazul de utilizare respectiv.");
1061			printf("\n3)	c) o entitate structurala (un subsistem) din cadrul sistemului respectiv care cuprinde o realizare a unei functiuni.\n");
1062			scanf("%d", &var);
1063			if (var == 1)
1064			{
1065				printf("\nCorect");
1066				corect++;
1067			}
1068			else
1069				printf("\nIncorect 1");
1070			break;
1071		case 79:
1072			printf("\n78. In UML conectarea modelului de obiecte cu modelul cazurilor de utilizare se realizeaza prin aceea ca:");
1073			printf("\n1)	a) fiecare caz de utilizare corespunde cate unui obiect");
1074			printf("\n2)	b) fiecare caz de utilizare va fi realizat de un set de obiecte care lucreaza impreuna.");
1075			printf("\n3)	c) fiecare model de obiecte este realizat de un set de cazuri de utilizare care trimite secvente de mesaje.\n");
1076			printf("\n nu stiu raspunsul ,puteti pune ce vreti voi eu pun la intamplare una ");
1077			scanf("%d", &var);
1078			if (var == 3)
1079			{
1080				printf("\nCorect");
1081				corect++;
1082			}
1083			else
1084				printf("\nIncorect");
1085			break;
1086		case 80:
1087			printf("\n79. O stare este:");
1088			printf("\n1)	a) o descriere a comportamentului unui obiect in timpul intrarii,iesirii sau persistentei.");
1089			printf("\n2) 	b) o conditie de existenta a unui clasificator (clasa sau caz de utilizare) care persista o perioada semnificativa de timp si poate fi cumva distinsa fata de alte conditii similare de existenta.");
1090			printf("\n3)	c) o descriere complet constructiva de descompunere a comportamentului complex in bucati mai mici, fiecare fiind valabila in anumite conditii specifice.\n");
1091			scanf("%d", &var);
1092			if (var == 2)
1093			{
1094				printf("\nCorect");
1095				corect++;
1096			}
1097			else
1098				printf("\nIncorect 2");
1099			break;
1100		case 81:
1101			printf("\n80. Pentru identificarea cazurilor de utilizare analistul sta de vorba cu clientul si ii adreseaza intrebari cheie precum:");
1102			printf("\n1)	a) care este rolul actorilor si al sistemului in fiecare scenariu? Care sunt interactiunile (fluxurile)? Care sunt secventele de evenimente si date si posibile variatiuni?");
1103			printf("\n2)	b) care sunt actorii? Care sunt mesajele pe care le trimit si receptioneaza? Care sunt grupele care alcatuiesc cazuri de utilizare?");
1104			printf("\n3)	c) care sunt functiile primare ale sistemului? Care sunt functiile secundare ale sistemului? De ce a fost construit sistemul? Ce inlocuieste si de ce?\n");
1105			scanf("%d", &var);
1106			if (var == 3)
1107			{
1108				printf("\nCorect");
1109				corect++;
1110			}
1111			else
1112				printf("\nIncorect 3");
1113			break;
1114		case 82:
1115			printf("\n81. In UML comportamentul continual este modelat prin:");
1116			printf("\n1)	a) un limbaj propriu de simulare (SimUML)");
1117			printf("\n2)	b) nu exista posibilitati directe de simulare in UML");
1118			printf("\n3)	c) comportament de stare\n");
1119			scanf("%d", &var);
1120			if (var == 2)
1121			{
1122				printf("\nCorect");
1123				corect++;
1124			}
1125			else
1126				printf("\nIncorect 2");
1127			break;
1128		case 83:
1129			printf("\n82. Agregarea este:");
1130			printf("\n1)	a) un tip special de asociere care implica proprietatea logica sau fizica.");
1131			printf("\n2)	b) o forma tare de compozitie in care partile sunt in intregime in responsabilitatea clasei compozite");
1132			printf("\n3)	c) o relatie de tip clasa parinte/clasa descendent\n");
1133			scanf("%d", &var);
1134			if (var == 1)
1135			{
1136				printf("\nCorect");
1137				corect++;
1138			}
1139			else
1140				printf("\nIncorect 1");
1141			break;
1142		case 84:
1143			printf("\n83. Asocierile sunt:");
1144			printf("\n1)	a) relatii care se manifesta la rulare pentru a permite schimb de mesaje intre obiecte");
1145			printf("\n2)	b) relatii de colaborare definite prin existenta unui server si respectiv a unui pachet de metode");
1146			printf("\n3)	c) codificate prin existenta unei clase asociative\n");
1147			scanf("%d", &var);
1148			if (var == 1)
1149			{
1150				printf("\nCorect");
1151				corect++;
1152			}
1153			else
1154				printf("\nIncorect 1");
1155			break;
1156		case 85:
1157			printf("\n84. In UML o operatie este:");
1158			printf("\n1)	a) specificarea unui comportament");
1159			printf("\n2)	b) specificarea unui mesaj");
1160			printf("\n3)	c) descrierea unui secvente de apeluri de metode\n");
1161			scanf("%d", &var);
1162			if (var == 1)
1163			{
1164				printf("\nCorect");
1165				corect++;
1166			}
1167			else
1168				printf("\nIncorect 1");
1169			break;
1170		case 86:
1171			printf("\n85. Diagramele de secventa sunt:");
1172			printf("\n1)	a) cea mai uzuala cale de reprezentare a scenariilor");
1173			printf("\n2)	b) cea mai uzuala cale de reprezentare a cazurilor de utilizare");
1174			printf("\n3)	c) diagrame care cuprind caile de realizare a asocierilor dintre obiecte si mesaje\n");
1175			scanf("%d", &var);
1176			if (var == 1)
1177			{
1178				printf("\nCorect");
1179				corect++;
1180			}
1181			else
1182				printf("\nIncorect 1");
1183			break;
1184		case 87:
1185			printf("\n86. Tipurile de operatii sunt:");
1186			printf("\n1)	a) constructor, destructor, modificator, selector, iterator");
1187			printf("\n2)	b) ortogonale, primitive, compozite, colectii, containere");
1188			printf("\n3)	c) binare, constructor, destructor, primitive, ne-primitive\n");
1189			scanf("%d", &var);
1190			if (var == 1)
1191			{
1192				printf("\nCorect");
1193				corect++;
1194			}
1195			else
1196				printf("\nIncorect 1");
1197			break;
1198		case 88:
1199			printf("\n87. Un sablon (pattern)");
1200			printf("\n1)	a) abstractizeaza si identifica aspectele cheie ale unei structuri comune de proiectare pe care o face utila pentru crearea unui design OO, reutilizabil.");
1201			printf("\n2)	b) abstractizeaza si identifica aspectele cheie ale unei structuri comune de proiectare in care o singura sursa de informatie actioneaza ca un server pentru mai multi clienti.");
1202			printf("\n3)	c) abstractizeaza si identifica aspectele cheie ale unei structuri comune de proiectare prin utilizarea claselor abstracte si a mostenirii si a functiilor virtuale.\n");
1203			scanf("%d", &var);
1204			if (var == 1)
1205			{
1206				printf("\nCorect");
1207				corect++;
1208			}
1209			else
1210				printf("\nIncorect 1");
1211			break;
1212		case 89:
1213			printf("\n88. Sablonul Container este o buna solutie pentru cazul:");
1214			printf("\n1)	a) cand un obiect are asociere 1 la mai multi si dorim sa imbunatatim reuzabilitatea si atunci acea clasa de la capatul „1”  va gestiona un set de obiecte stocate intr-un container.");
1215			printf("\n2)b) cand devine mai usoara adaugarea unui nou container –un vector extensibil-prin crearea unei interfete care asigura clientilor serviciile cerute de acestia dar folosesc operatiile primitive ale containerelor existente.");
1216			printf("\n3)c) cand un obiect are nevoie de o implementare comuna potrivita pentru o varietate de utilizari.\n");
1217			scanf("%d", &var);
1218			if (var == 1)
1219			{
1220				printf("\nCorect");
1221				corect++;
1222			}
1223			else
1224				printf("\nIncorect 1");
1225			break;
1226		case 90:
1227			printf("\n89. Cand, in cadrul sablonului Observer, serverul primeste un apel subscribe");
1228			printf("\n1)	a) apeleaza periodic o metoda Gimme() de interogare direct a valorii urmarite");
1229			printf("\n2)	b) creaza un obiect NotificationHandle care include adresa obiectului.");
1230			printf("\n3)	c) creaza un obiect de tip ConcreteObserver care adauga stocarea locala in aributele dorite.\n");
1231			scanf("%d", &var);
1232			if (var == 3)
1233			{
1234				printf("\nCorect");
1235				corect++;
1236			}
1237			else
1238				printf("\nIncorect 3");
1239			break;
1240		case 91:
1241			printf("\n90. Un sablon (pattern) este:");
1242			printf("\n1)	a) o structura de program orientat pe obiecte");
1243			printf("\n2)b) o regula care leaga printr-o ierarhie de clase o descriere de solutie de un set de specificatii.");
1244			printf("\n3)c) o regula care exprima o relatie dintre un context,o problema si o solutie.\n");
1245			scanf("%d", &var);
1246			if (var == 3)
1247			{
1248				printf("\nCorect");
1249				corect++;
1250			}
1251			else
1252				printf("\nIncorect 3");
1253			break;
1254		case 92:
1255			printf("\n91. Sablonul Observer rezolva problema");
1256			printf("\n1)	a) in care un server trebuie sa furnizeze la cerere date citite din proces");
1257			printf("\n2)	b) in care un obiect trebuie sa afiseze periodic (observe) schimbarile survenite in valorile citite de la un senzor");
1258			printf("\n3)	c) in care o singura sursa de informatie actioneaza ca un server pentru mai multi clienti care trebuie sa isi actualizeze autonom datele cand acestea se schimba.\n");
1259			scanf("%d", &var);
1260			if (var == 3)
1261			{
1262				printf("\nCorect");
1263				corect++;
1264			}
1265			else
1266				printf("\nIncorect 3");
1267			break;
1268		case 93:
1269			printf("\n92. La un sablon Interface participa clasele:");
1270			printf("\n1)	a) Stack, List, Interface");
1271			printf("\n2)	b) Client, Server, List, Interface");
1272			printf("\n3)	c) Client, Interface, Implementation\n");
1273			scanf("%d", &var);
1274			if (var == 3)
1275			{
1276				printf("\nCorect");
1277				corect++;
1278			}
1279			else
1280				printf("\nIncorect 3");
1281			break;
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299		/*case 94:
1300			printf("\nParametri efectivi sunt:");
1301			printf("\n1)valori curente ale variabilelor utilizate la fct");
1302			printf("\n2)valori care apar in declaratia unei fct");
1303			printf("\n3)variabile locale ale fct\n");
1304			scanf("%d", &var);
1305			if (var == 1)
1306			{
1307				printf("\nCorect");
1308				corect++;
1309			}
1310			else
1311				printf("\nIncorect");
1312			break;
1313		case 95:
1314			printf("\nCorespondentul hexazecimalului al lui 109 zecimal este");
1315			printf("\n1)0x6D");
1316			printf("\n2)0x613");
1317			printf("\n3)0xA9\n");
1318			scanf("%d", &var);
1319			if (var == 1)
1320			{
1321				printf("\nCorect");
1322				corect++;
1323			}
1324			else
1325				printf("\nIncorect");
1326			break;
1327		case 96:
1328			printf("\nTipul <unsigned char> se reprezinta pe:");
1329			printf("\n1)1 octet, cu semn");
1330			printf("\n2)1 octet, fara semn");
1331			printf("\n3)2 octet, fara semn\n");
1332			scanf("%d", &var);
1333			if (var == 2)
1334			{
1335				printf("\nCorect");
1336				corect++;
1337			}
1338			else
1339				printf("\nIncorect");
1340			break;
1341		case 97:
1342			printf("\nPt a inmulti un nr cu 4 se poate folosi operatia de deplasare");
1343			printf("\n1)cu 2 poz la stanga");
1344			printf("\n2)cu o poz la stanga");
1345			printf("\n3)cu 2 poz la dreapta\n");
1346			scanf("%d", &var);
1347			if (var == 1)
1348			{
1349				printf("\nCorect");
1350				corect++;
1351			}
1352			else
1353				printf("\nIncorect");
1354			break;
1355		case 98:
1356			printf("\nFgetpos are ca efect");
1357			printf("\n1)setarea pointerului fisier asociat cu fluxul curent la o noua pozitie");
1358			printf("\n2)setarea poz pointerului fisier asociata cu fluxul curent");
1359			printf("\n3)memorarea locatiei pointerului fisier asociata cu fluxul curent\n");
1360			scanf("%d", &var);
1361			if (var == 3)
1362			{
1363				printf("\nCorect");
1364				corect++;
1365			}
1366			else
1367				printf("\nIncorect");
1368			break;
1369		case 99:
1370			printf("\nInternetul este");
1371			printf("\n1)o colectie de informatii");
1372			printf("\n2)un serviciu");
1373			printf("\n3)o infrastructura fizica\n");
1374			scanf("%d", &var);
1375			if (var == 3)
1376			{
1377				printf("\nCorect");
1378				corect++;
1379			}
1380			else
1381				printf("\nIncorect");
1382			break;
1383		case 100:
1384			printf("\nCompilatorul este");
1385			printf("\n1)un program care traduce programele surs in pr obiect");
1386			printf("\n2)un echipament de calcul");
1387			printf("\n3)un program care traduce programele obiect in prog sursa\n");
1388			scanf("%d", &var);
1389			if (var == 1)
1390			{
1391				printf("\nCorect");
1392				corect++;
1393			}
1394			else
1395				printf("\nIncorect");
1396			break;
1397		case 101:
1398			printf("\nTipuri de memorie interna");
1399			printf("\n1)ROM, RAM");
1400			printf("\n2)CD-ROM, ROM");
1401			printf("\n3)Hard-Disk si ROM\n");
1402			scanf("%d", &var);
1403			if (var == 1)
1404			{
1405				printf("\nCorect");
1406				corect++;
1407			}
1408			else
1409				printf("\nIncorect");
1410			break;
1411		case 102:
1412			printf("\nCare dintre urmatorii operatori are cea mai mare prioritate");
1413			printf("\n1)=");
1414			printf("\n2)+");
1415			printf("\n3)/\n");
1416			scanf("%d", &var);
1417			if (var == 3)
1418			{
1419				printf("\nCorect");
1420				corect++;
1421			}
1422			else
1423				printf("\nIncorect");
1424			break;
1425		case 103:
1426			printf("\nCare dintre urmatorii operatori are cea mai mica prioritate");
1427			printf("\n1)=");
1428			printf("\n2)+");
1429			printf("\n3)/\n");
1430			scanf("%d", &var);
1431			if (var == 1)
1432			{
1433				printf("\nCorect");
1434				corect++;
1435			}
1436			else
1437				printf("\nIncorect");
1438			break;
1439		case 104:
1440			printf("\nPrecizati ce reprezinta int(*)(int a, float b)");
1441			printf("\n1)reprezinta o fct care retine un pointer catre un intreg");
1442			printf("\n2)reprezinta un pointer catre o fct ce retine un intreg");
1443			printf("\n3)incorect\n");
1444			scanf("%d", &var);
1445			if (var == 2)
1446			{
1447				printf("\nCorect");
1448				corect++;
1449			}
1450			else
1451				printf("\nIncorect");
1452			break;
1453		case 105:
1454			printf("\nPt a face interschimbarea a 2 var de acelasi tip fara a folosi o a treiea variabila, afisarea corecta este:");
1455			printf("\n1)a=a*b;b=a*b;a=b/a");
1456			printf("\n2)a=a*b;b=a/b;a=a/b;");
1457			printf("\n3)b=a*b;a=a/b;b=a*b;\n");
1458			scanf("%d", &var);
1459			if (var == 2)
1460			{
1461				printf("\nCorect");
1462				corect++;
1463			}
1464			else
1465				printf("\nIncorect");
1466			break;
1467		case 106:
1468			printf("\nBIOS este");
1469			printf("\n1)un echipament");
1470			printf("\n2)un program aflat in memoria RAM");
1471			printf("\n3)un program aflat in memoria ROM\n");
1472			scanf("%d", &var);
1473			if (var == 3)
1474			{
1475				printf("\nCorect");
1476				corect++;
1477			}
1478			else
1479				printf("\nIncorect");
1480			break;
1481		case 107:
1482			printf("\nPt secventa de program\ntypdef struct\n{int r, im;}ax;\nax c;\ncare este variabila corecta pentru citire?");
1483			printf("\n1)scanf(<<o/o d>>, &c);");
1484			printf("\n2)nu se poate efectua citirea");
1485			printf("\n3)scanf(<< o/o d o/o d, &c.re, &c.in);\n");
1486			scanf("%d", &var);
1487			if (var == 3)
1488			{
1489				printf("\nCorect");
1490				corect++;
1491			}
1492			else
1493				printf("\nIncorect");
1494			break;
1495		case 108:
1496			printf("\nTipurile caracterizate prin intervalul <int> se reprez in memorie prin");
1497			printf("\n1)2 octeti, cu semn");
1498			printf("\n2)1 octet, fara semn");
1499			printf("\n3)2 octet, fara semn\n");
1500			scanf("%d", &var);
1501			if (var == 1)
1502			{
1503				printf("\nCorect");
1504				corect++;
1505			}
1506			else
1507				printf("\nIncorect");
1508			break;
1509		case 109:
1510			printf("\nProgramul:\nint main()\n{char string[10];\nchar *str1=<<abcdefghi>>;\ncrlscr();\nstrncpy(string, str1, 3);\nstring[3]=<*backslah*0>;\nprintf(<< o/o s>>, string);\nreturn 0;}\nafiseaza pe ecran");
1511			printf("\n1)def");
1512			printf("\n2)abcdefghi");
1513			printf("\n3)abc\n");
1514			scanf("%d", &var);
1515			if (var == 3)
1516			{
1517				printf("\nCorect");
1518				corect++;
1519			}
1520			else
1521				printf("\nIncorect");
1522			break;
1523		case 110:
1524			printf("\nCare din urmatoarele structuri are sinteza corecta?");
1525			printf("\n1)examen, *examene, examen");
1526			printf("\n2)examen,m examen[examen]");
1527			printf("\n3)examen, examen, exAmen\n");
1528			scanf("%d", &var);
1529			if (var == 3)
1530			{
1531				printf("\nCorect");
1532				corect++;
1533			}
1534			else
1535				printf("\nIncorect");
1536			break;
1537		case 111:
1538			printf("\n-0.00000021 se reprezinta ca");
1539			printf("\n1)-2.1E7");
1540			printf("\n2)-2.1E10-7");
1541			printf("\n3)-2.1E-7\n");
1542			scanf("%d", &var);
1543			if (var == 3)
1544			{
1545				printf("\nCorect");
1546				corect++;
1547			}
1548			else
1549				printf("\nIncorect");
1550			break;
1551		case 112:
1552			printf("\nPt secventa de program ce efect se obtine?\nchar c[20]=<<>>;\nFILE *f;\nf = fopen(<<test.bin>>, <<rb>>);\nfseek(f, -2, SEEK_END);\nfread(c, 2, 1, f);\nfclose();");
1553			printf("\n1)citeste primii 2 octeti din fisier");
1554			printf("\n2)citeste ultimii 2 octeti din fisier");
1555			printf("\n3)citeste ultimii 20 octeti din fisier\n");
1556			scanf("%d", &var);
1557			if (var == 3)
1558			{
1559				printf("\nCorect");
1560				corect++;
1561			}
1562			else
1563				printf("\nIncorect");
1564			break;
1565		case 113:
1566			printf("\nDezalocarea memoriei ocupate de variabilele alocate dinamic trebuie facuta, in limbajul C:");
1567			printf("\n1)explicit, de catre programator");
1568			printf("\n2)explicit sau implicit(de catre mediul de programare)1");
1569			printf("\n3)explicit, de catre utilizator\n");
1570			scanf("%d", &var);
1571			if (var == 1)
1572			{
1573				printf("\nCorect");
1574				corect++;
1575			}
1576			else
1577				printf("\nIncorect");
1578			break;
1579		case 114:
1580			printf("\nUn broswer este:");
1581			printf("\n1)un motor de cautare");
1582			printf("\n2)un program care permite gasirea si vizualizareaa informatiei");
1583			printf("\n3)un document multimedia\n");
1584			scanf("%d", &var);
1585			if (var == 2)
1586			{
1587				printf("\nCorect");
1588				corect++;
1589			}
1590			else
1591				printf("\nIncorect");
1592			break;
1593		case 115:
1594			printf("\nTipuri de memorie externa");
1595			printf("\n1)discuri flexibile, cadre");
1596			printf("\n2)memoria RAM, Hard-disk-ul");
1597			printf("\n3)CD-ROM, Hard-Disk\n");
1598			scanf("%d", &var);
1599			if (var == 3)
1600			{
1601				printf("\nCorect");
1602				corect++;
1603			}
1604			else
1605				printf("\nIncorect");
1606			break;
1607		case 116:
1608			printf("\nLa retelele de tip stea comunicarea intre 2 noduri se fac");
1609			printf("\n1)prin intermediul nodului central");
1610			printf("\n2)nodul din partea dreapta comunica cu cel din partea stanga");
1611			printf("\n3)nodul din partea stanga comunica cu celelalte\n");
1612			scanf("%d", &var);
1613			if (var == 1)
1614			{
1615				printf("\nCorect");
1616				corect++;
1617			}
1618			else
1619				printf("\nIncorect");
1620			break;
1621		case 117:
1622			printf("\n Ce valoare zecimala are 0x3D");
1623			printf("\n1)16");
1624			printf("\n2)39");
1625			printf("\n3)61\n");
1626			scanf("%d", &var);
1627			if (var == 3)
1628			{
1629				printf("\nCorect");
1630				corect++;
1631			}
1632			else
1633				printf("\nIncorect");
1634			break;
1635		case 118:
1636			printf("\nTipul int este definit pe urmatorul domeniu de valori");
1637			printf("\n1)-255 255");
1638			printf("\n2)-256 256");
1639			printf("\n3)-32768 32678\n");
1640			scanf("%d", &var);
1641			if (var == 3)
1642			{
1643				printf("\nCorect");
1644				corect++;
1645			}
1646			else
1647				printf("\nIncorect");
1648			break;
1649		case 119:
1650			printf("\nTipului real i se pot aplica operatiile care au rezultat real");
1651			printf("\n1)<, <=, >, =>");
1652			printf("\n2)abs(x), pow(x), sqrt(x)");
1653			printf("\n3)eof, eol\n");
1654			scanf("%d", &var);
1655			if (var == 2)
1656			{
1657				printf("\nCorect");
1658				corect++;
1659			}
1660			else
1661				printf("\nIncorect");
1662			break;
1663		case 120:
1664			printf("\nIn urma executiei programului urmator:\nint main()\n{char *str1=<<inginerie>>, *str2 = <<ner>>, *ptr;\nptr = strstr(str1, str2);\nprintf(<<rezultatul este o/o s>, ptr);\n}\nse va afisa");
1665			printf("\n1)5");
1666			printf("\n2)nerie");
1667			printf("\n3)ner\n");
1668			scanf("%d", &var);
1669			if (var == 2)
1670			{
1671				printf("\nCorect");
1672				corect++;
1673			}
1674			else
1675				printf("\nIncorect");
1676			break;
1677		case 121:
1678			printf("\nCe afiseaza urmatoarea secventa de program:\nint x=16;\nprintf(<<o/o x>>, x);");
1679			printf("\n1)16");
1680			printf("\n2)10");
1681			printf("\n3)x\n");
1682			scanf("%d", &var);
1683			if (var == 2)
1684			{
1685				printf("\nCorect");
1686				corect++;
1687			}
1688			else
1689				printf("\nIncorect");
1690			break;
1691		case 122:
1692			printf("\nRezultatul operatiei a/(float)b cu a si b de tip intreg este:");
1693			printf("\n1)float");
1694			printf("\n2)int");
1695			printf("\n3)double\n");
1696			scanf("%d", &var);
1697			if (var == 1)
1698			{
1699				printf("\nCorect");
1700				corect++;
1701			}
1702			else
1703				printf("\nIncorect");
1704			break;
1705		case 123:
1706			printf("\nPt a imparti un nr cu 2 se poate folosi operatia de deplasare");
1707			printf("\n1)cu o poz spre stanga");
1708			printf("\n2)cu o poz spre dreapta");
1709			printf("\n3)cu 2 poz spre stanga\n");
1710			scanf("%d", &var);
1711			if (var == 2)
1712			{
1713				printf("\nCorect");
1714				corect++;
1715			}
1716			else
1717				printf("\nIncorect");
1718			break;
1719		case 124:
1720			printf("\nAlegeti varianta corecta relativ la secventa urmatoare\nchar c;\nchar *const cp = sc;");
1721			printf("\n1)cp nu trebuie modificat, desi entiatea pe care o indica poate fi modificata");
1722			printf("\n2)cp poate fi modificat, la fel si entitatea pe care o indica");
1723			printf("\n3)cp poate fi modificat, dar entitatea pe care o indica nu poate fi modificata\n");
1724			scanf("%d", &var);
1725			if (var == 1)
1726			{
1727				printf("\nCorect");
1728				corect++;
1729			}
1730			else
1731				printf("\nIncorect");
1732			break;
1733		case 125:
1734			printf("\nPrecizati ce va afisa secventa de mai jos:\nint (*fct)(int a, int b);\nint suma(int a, int b){return a+b;}\nint diferenta(int a, int b){return a-b;}\nint main()\n{int a=12, b=9;\nif(a&b)fct =suma;\nelse fct=diferenta;\nprintf(<<o/o d>>, (*fct)(a, b));\n return 0;\n}");
1735			printf("\n1)9");
1736			printf("\n2)15");
1737			printf("\n3)secventa e gresita\n");
1738			scanf("%d", &var);
1739			if (var == 1)
1740			{
1741				printf("\nCorect");
1742				corect++;
1743			}
1744			else
1745				printf("\nIncorect");
1746			break;
1747		case 126:
1748			printf("\nModul test considera ecranul");
1749			printf("\n1)la fct ca si modul grafic");
1750			printf("\n2)format din pozitii caracter");
1751			printf("\n3)ca un patrat\n");
1752			scanf("%d", &var);
1753			if (var == 2)
1754			{
1755				printf("\nCorect");
1756				corect++;
1757			}
1758			else
1759				printf("\nIncorect");
1760			break;
1761		case 127:
1762			printf("\nUn tip in programare reprezinta");
1763			printf("\n1)o multime de valori careia i se poate atasa un nume");
1764			printf("\n2)o multime de variabile");
1765			printf("\n3)un subdomeniu\n");
1766			scanf("%d", &var);
1767			if (var == 1)
1768			{
1769				printf("\nCorect");
1770				corect++;
1771			}
1772			else
1773				printf("\nIncorect");
1774			break;
1775		case 128:
1776			printf("\nCorespondentul hexazecimal al lui 73 zecimal este");
1777			printf("\n1)0x10");
1778			printf("\n2)0x49");
1779			printf("\n3)0x2A\n");
1780			scanf("%d", &var);
1781			if (var == 2)
1782			{
1783				printf("\nCorect");
1784				corect++;
1785			}
1786			else
1787				printf("\nIncorect");
1788			break;
1789		case 129:
1790			printf("\nIndicati ce reprezinta expresia\nint *funct(int a, float b);");
1791			printf("\n1)reprezinta o functie care relationeaza un pointer catre un intreg");
1792			printf("\n2)reprezinta un pointer catre o fct care rel cu un intreg");
1793			printf("\n3)reprezinta o declaratie incorecta\n");
1794			scanf("%d", &var);
1795			if (var == 1)
1796			{
1797				printf("\nCorect");
1798				corect++;
1799			}
1800			else
1801				printf("\nIncorect");
1802			break;
1803		case 130:
1804			printf("\nCare dintre urmatoarele instructiuni sunt iterative");
1805			printf("\n1)<while> si <do-while>");
1806			printf("\n2)<case> si <do-while>");
1807			printf("\n3)<;f> si <while>\n");
1808			scanf("%d", &var);
1809			if (var == 1)
1810			{
1811				printf("\nCorect");
1812				corect++;
1813			}
1814			else
1815				printf("\nIncorect");
1816			break;
1817		case 131:
1818			printf("\nIn urma executiei secventei de mai jos se vor afisa\nint main()\n{int tab[3][3]={1,2,3,4,5,6,7,8,9};\nint i, j;\nfor(i=0;i<3-1;i++)\n\tfor(j=0;j<3-1-i;j++)\n\t\tprintf(<<o/o d>>, tab[i][j]);\nreturn 0;\n}");
1819			printf("\n1)el de pe DS");
1820			printf("\n2)el de deasupra DS");
1821			printf("\n3)el de deasupra DP\n");
1822			scanf("%d", &var);
1823			if (var == 2)
1824			{
1825				printf("\nCorect");
1826				corect++;
1827			}
1828			else
1829				printf("\nIncorect");
1830			break;
1831		case 132:
1832			printf("\nIn urma executiei secventei de mai jos se vor afisa\nint main()\n{int tab[3][3]={1,2,3,4,5,6,7,8,9};\nint i, j;\nfor(i=0;i<3;i++)\n\tfor(j=0;j<=i;j++)\n\t\tprintf(<<o/o d>>, tab[i][j]);\nreturn 0;\n}");
1833			printf("\n1)el de pe DS");
1834			printf("\n2)el de pe DP");
1835			printf("\n3)el de pe si de sub DP\n");
1836			scanf("%d", &var);
1837			if (var == 3)
1838			{
1839				printf("\nCorect");
1840				corect++;
1841			}
1842			else
1843				printf("\nIncorect");
1844			break;
1845		case 133:
1846			printf("\nCe afiseaza uurmatoarea secventa pt variabila\n#include <stdio.h>\nint main()\n{int var=77;\nprintf(<<Variabila var este o/o c>>, var);\n}");
1847			printf("\n1)un intreg zecimal");
1848			printf("\n2)un caracter ASCII");
1849			printf("\n3)un sir de caractere\n");
1850			scanf("%d", &var);
1851			if (var == 2)
1852			{
1853				printf("\nCorect");
1854				corect++;
1855			}
1856			else
1857				printf("\nIncorect");
1858			break;
1859		case 134:
1860			printf("\nCe va returna urmatorul program dupa executie?\nint main()\n{int i;\nfor(i=0;i<20,i++)\n{if(i%2==0)\n\tcontinue;\n\tprintf(<<o/o d>>, i);\n}\nreturn 0;\n}");
1861			printf("\n1)2 4 6 8 10 12 14 16 18 20");
1862			printf("\n2)1 3 5 7 9 11 13 15 17 19");
1863			printf("\n3)2 4 6 8 10 12 14 16 18\n");
1864			scanf("%d", &var);
1865			if (var == 2)
1866			{
1867				printf("\nCorect");
1868				corect++;
1869			}
1870			else
1871				printf("\nIncorect");
1872			break;
1873		case 135:
1874			printf("\nCe valoare are variabila n?\nint m=524;int n = m++ o/o 20;");
1875			printf("\n1)10");
1876			printf("\n2)4");
1877			printf("\n3)2\n");
1878			scanf("%d", &var);
1879			if (var == 2)
1880			{
1881				printf("\nCorect");
1882				corect++;
1883			}
1884			else
1885				printf("\nIncorect");
1886			break;
1887		case 136:
1888			printf("\nCe valoare are variabila c?\nchar c = (3<<5)/32-2+<a>;");
1889			printf("\n1)b");
1890			printf("\n2)a");
1891			printf("\n3)z\n");
1892			scanf("%d", &var);
1893			if (var == 1)
1894			{
1895				printf("\nCorect");
1896				corect++;
1897			}
1898			else
1899				printf("\nIncorect");
1900			break;
1901		case 137:
1902			printf("\nIn secventa int *const cpi=&i\ncpi este:");
1903			printf("\n1)un pointer catre un intreg");
1904			printf("\n2)un pointer constant catre un intreg");
1905			printf("\n3)un pointer catre o constanta intreaga\n");
1906			scanf("%d", &var);
1907			if (var == 2)
1908			{
1909				printf("\nCorect");
1910				corect++;
1911			}
1912			else
1913				printf("\nIncorect");
1914			break;
1915		case 138:
1916			printf("\nProgramul\n#include <stdio.h>\nint main()\n{\nchar **ptr=NULL;\nchar *p=NULL;\nchar c=<d>;\np=&c;\nptr=&p;\nprintf(<<c=[o/o c]>>, c);\nprintf(<<*p=[o/o c]>>, *p);\nprintf(<<**ptr[o/o c]>>, **ptr);\nreturn 0;}\nare ca efect");
1917			printf("\n1)c=[d] *p=0x002bfe0b **p=0x002bfe14");
1918			printf("\n2)c=[d] *p=[d] **p=0x002bfe17");
1919			printf("\n3)c=[d] *p=[d] **p=[d]\n");
1920			scanf("%d", &var);
1921			if (var == 3)
1922			{
1923				printf("\nCorect");
1924				corect++;
1925			}
1926			else
1927				printf("\nIncorect");
1928			break;
1929		case 139:
1930			printf("\nCe valoare va avea variabila p in urmatorul rand de cod\np = strstr(s1, s2);\ndaca s1 si s2 sunt 2 siruri citite de la tastatura");
1931			printf("\n1)un pointer de tip char care dc este nenul, s1 contine s2");
1932			printf("\n2)un pointer de tip intreg care dc este nenul, s1 contine s2");
1933			printf("\n3)un pointer de tip char care dc este nenul, s2 contine s1\n");
1934			scanf("%d", &var);
1935			if (var == 1)
1936			{
1937				printf("\nCorect");
1938				corect++;
1939			}
1940			else
1941				printf("\nIncorect");
1942			break;
1943		case 140:
1944			printf("\nProgramul\nint main()\n{char string[10];\nchar *str1=<<marsupial>>;\nstrcpy(string, str1, 4);\nstring[4]=<\o>;\nprintf(<< o/o s>>, string);\nreturn 0;\n}\nafiseaza pe ecran");
1945			printf("\n1)marsupial");
1946			printf("\n2)mar");
1947			printf("\n3)mars\n");
1948			scanf("%d", &var);
1949			if (var == 3)
1950			{
1951				printf("\nCorect");
1952				corect++;
1953			}
1954			else
1955				printf("\nIncorect");
1956			break;
1957		case 141:
1958			printf("\nParametrii formali sunt:");
1959			printf("\n1)care apar in declaratia unei fct");
1960			printf("\n2)care apar in apelul unei fct");
1961			printf("\n3)care se transmit in afara fct\n");
1962			scanf("%d", &var);
1963			if (var == 1)
1964			{
1965				printf("\nCorect");
1966				corect++;
1967			}
1968			else
1969				printf("\nIncorect");
1970			break;
1971		case 142:
1972			printf("\nCare este rezultatul urmatorului program?\ntest(char *x, char y)\n{*x=y; y=<1>; printf(<< o/o c o/o c>>, x, y);}\nint main()\n{char m = <2>;\nchar n = <3>;\ntest(&m, n);\nprintf(<<o/o c o/o c>>, m, n);}");
1973			printf("\n1)3313");
1974			printf("\n2)3131");
1975			printf("\n3)3133\n");
1976			scanf("%d", &var);
1977			if (var == 3)
1978			{
1979				printf("\nCorect");
1980				corect++;
1981			}
1982			else
1983				printf("\nIncorect");
1984			break;
1985		case 143:
1986			printf("\nCare este rezultatul programului urmator\nint main()\n{int rez1, rez2;\nint(*pFunc)(int, int);\npFunc = func;\nrez1=(*pFunc)(10, 20);\nrez2=pFunc(10, 20);\nprintf(<<Rezultat 1=o/o d Rezultat 2=o/o d>>, rez1, rez2);\nreturn 0;\n}\nint func(int x, int y){return x-y;}");
1987			printf("\n1)Rezultat 1=-10 Rezultat 2=-10");
1988			printf("\n2)Rezultat 1=-10 Rezultat 2=-20");
1989			printf("\n3)Eroare de compilare\n");
1990			scanf("%d", &var);
1991			if (var == 1)
1992			{
1993				printf("\nCorect");
1994				corect++;
1995			}
1996			else
1997				printf("\nIncorect");
1998			break;
1999		case 144:
2000			printf("\nCe valoare zecimala are 0xAF");
2001			printf("\n1)175");
2002			printf("\n2)150");
2003			printf("\n3)25\n");
2004			scanf("%d", &var);
2005			if (var == 1)
2006			{
2007				printf("\nCorect");
2008				corect++;
2009			}
2010			else
2011				printf("\nIncorect");
2012			break;
2013		case 145:
2014			printf("\nSecventa:\nchar ch=<c>;\nconst char *ptr=&ch;*ptr=<a>;\neste:");
2015			printf("\n1)corecta");
2016			printf("\n2)eronata pt ca se modifica un pointer constant");
2017			printf("\n3)eronata pt ca se modifica o val constanta\n");
2018			scanf("%d", &var);
2019			if (var == 3)
2020			{
2021				printf("\nCorect");
2022				corect++;
2023			}
2024			else
2025				printf("\nIncorect");
2026			break;
2027		case 146:
2028			printf("\nIn urma executiei programului urmator:\nint main()\n{char *str1=<<calambur>>;\n*str2 = <<amb>>, *ptr;\nptr = strstr(str1, str2);\nprintf(<<Rezulatul este: o/o s>>, ptr);\nreturn 0;\n}\nse va afisa");
2029			printf("\n1)5");
2030			printf("\n2)amb");
2031			printf("\n3)ambur\n");
2032			scanf("%d", &var);
2033			if (var == 3)
2034			{
2035				printf("\nCorect");
2036				corect++;
2037			}
2038			else
2039				printf("\nIncorect");
2040			break;
2041		case 147:
2042			printf("\nCe afiseaza urmatoarea secventa de program?\nint m = 322;\nint n = m++ o/o 10;");
2043			printf("\n1)3");
2044			printf("\n2)2");
2045			printf("\n3)22\n");
2046			scanf("%d", &var);
2047			if (var == 2)
2048			{
2049				printf("\nCorect");
2050				corect++;
2051			}
2052			else
2053				printf("\nIncorect");
2054		case 148:
2055			printf("\nAlegeti varianta corecta relativ la declaratia urmatoare\nfloat(*q)[];");
2056			printf("\n1)un tablou de pointeri catre variabile reale");
2057			printf("\n2)un pointer catre un tablou de variabile reale");
2058			printf("\n3)este eronata\n");
2059			scanf("%d", &var);
2060			if (var == 2)
2061			{
2062				printf("\nCorect");
2063				corect++;
2064			}
2065			else
2066				printf("\nIncorect");
2067			break;
2068		case 149:
2069			printf("\nstruct individ\n{char *nume;\nint varsta;\nfloat inaltime;\n}\ndefineste:");
2070			printf("\n1)un tip de structura");
2071			printf("\n2)o variabila de tip structura");
2072			printf("\n3)nimic\n");
2073			scanf("%d", &var);
2074			if (var == 1)
2075			{
2076				printf("\nCorect");
2077				corect++;
2078			}
2079			else
2080				printf("\nIncorect");
2081			break;*/
2082		}
2083	}
2084	printf("\nRezultate corecte: %d\n", corect);
2085}