Câu hỏi trắc nghiệm môn tin học đại cương

40 câu dễ và 60 câu khó
//------------------------------------------------------------------------1
1. Nếu hàm func( ) kiểu "int" và không có tham số thì có thể khai báo:

{
~ func( )
~ func(void)
= func(void) hoặc func( )
~ func
}
//------------------------------------------------------------------------1
2. Nếu không khai báo kiểu trả về của hàm thì được mặc định là:

{
~void
~char
=int
~float
}
//------------------------------------------------------------------------1
3. Phạm vi gọi hàm:
{
~Các hàm được gọi hàm main( )
~ Các hàm không được gọi hàm main( )
~ Các hàm được gọi bởi hàm main( )
= Các hàm được gọi bởi hàm main( ) và chúng có thể gọi lẫn nhau.
}
//-----------------------------------------------------------------------4. Tham số hình thức của hàm được khai báo :
{
~Như khai báo biến.
~Như khai báo mảng.

=Như khai báo biến nhưng không được khai báo chung.
~Khai báo khác.


}
//-----------------------------------------------------------------------5. Hàm được khai báo nguyên mẫu với:

{
~Tên hàm và danh sách tham số.
~Kiểu hàm và tên hàm.
~Kiểu hàm và danh sách tham số.
=Kiểu hàm, tên hàm và danh sách tham số.
}
//------------------------------------------------------------------------4
6. Hàm có thể khai báo nguyên mẫu và định nghĩa :

{
~Định nghĩa trong hàm main( ).
~Khai báo nguyên mẫu trong hàm main( ) và chỉ được gọi bởi hàm main( ).
~Khai báo nguyên mẫu ở đầu chương trình và chỉ được gọi bởi hàm main( ).
=Khai báo nguyên mẫu ở đầu chương trình và định nghĩa sau hàm main( ).
}
//------------------------------------------------------------------------2
7. *Danh sách tham số chỉ có tên hình thức thì có thể khai báo kiểu tham số:

{
~Sau “)” với các tham số cùng kiểu cũng phải khai báo riêng.
=Sau “)” với các tham số cùng kiểu có thể khai báo chung.
~Sau “{“ với các tham số cùng kiểu cũng phải khai báo riêng.
~Sau “{“ với các tham số cùng kiểu có thể khai báo chung.

}
//------------------------------------------------------------------------2
8. Trong lệnh gọi hàm, danh sách tham số thực sự truyền cho hàm:

{
~Như danh sách tham số hình thức trong khai báo.
~Phải có kiểu tham số.
~Đúng kiểu như trong khai báo.
=Đúng kiểu và đúng số tham số như trong khai báo.


}
//------------------------------------------------------------------------3
9. Biến cục bộ:

{
~Là biến được khai báo bên ngoài tất cả các hàm.
~Là biến được khai báo bên trong một hàm.
=Là biến được khai báo bên trong một hàm và chỉ được dùng trong hàm đó.
~Là biến được khai báo bên trong hoặc bên ngoài các hàm.
}
//------------------------------------------------------------------------3
10. Giữa biến cục bộ và biến toàn cục:

{
~Có thể trùng tên.
~Không được trùng tên.
~Nếu trùng tên thì biến cục bộ phải khai báo bên ngoài các hàm.
=Có thể trùng tên và lệnh trong hàm ưu tiên biến cục bộ.
}

//------------------------------------------------------------------------3
11. Một hàm có thể được gọi ở:

{
~Hàm main( ).
~Các hàm khác.
~Hàm main( ) và các hàm khác.
=Hàm main( ), các hàm khác và chính nó.
}
//------------------------------------------------------------------------4
12. Một hàm đệ quy:

{
~Không phải hàm main( ).
~Là hàm chuẩn.
~Là hàm do người dùng định nghĩa.


=Là hàm được định nghĩa qua chính nó.
}
//-----------------------------------------------------------------------13. *Khi hàm được gọi thì các lệnh trong hàm được thực hiện:

{
~Cho đến hết hàm.
~Cho đến khi gặp lệnh “break”.
~Cho đến khi gặp lệnh “exit”.
=Cho đến khi gặp lệnh “return” hoặc đến hết hàm.
}
//-----------------------------------------------------------------------14. *Cho hàm func(a, b : int){ a=b++ ;}. Hàm này bị lỗi vì:

{
~Không có khai báo kiểu trả về.
=Khai báo tham số không đúng.
~Không có lệnh “return”.
~Chưa có giá trị của biến b.
}
//------------------------------------------------------------------------1
15. *Cho hàm void swap (int a, int b){int temp=a ; a=b ; b=temp ;}.

Với các lệnh ở hàm main( ) : int n=5, k=7 ; swap(n, k) ;
thì sau khi thực hiện các lệnh, giá trị của các biến như sau :
{
~n=7, k=5.
~n=7, k=5, temp=7.
~n=5, k=7, temp=7.
=n=5, k=7.
}
//------------------------------------------------------------------------1
16. *Cho hàm void inc(int a){a++ ;}. Với các lệnh ở hàm main( ):

int a=5; inc(a) ; printf(" %d", a) ;
Kết quả là :
{


~6
=5
~Không có kết quả vì hàm trên bị lỗi.
~Không có kết quả vì biến trùng tên với tham số.
}

//------------------------------------------------------------------------1
17. Cho hàm sum(int *a, int n){ int i, s ; for (s=0, i=0 ; i
s;}.
Hàm trên để tính:
{
=Tổng mảng a gồm n số nguyên kiểu int.
~Đếm số phần tử trong mảng a.
~Hàm bị lỗi vì không khai báo kiểu trả về.
~Hàm bị lỗi vì lệnh: s=0, i=0;
}
//-----------------------------------------------------------------------18. *Cho hàm fact(int n){ int i, p=1 ; for (i=0 ; i
Hàm trên để tính:
{
~Tích mảng p gồm n số nguyên kiểu int.
~Tính n!.
~Hàm bị lỗi vì không khai báo kiểu trả về.
=Kết quả trả về là 0.
}
//------------------------------------------------------------------------4
19. Cho hàm fact(int n){ int i, p=1; for (i=2 ; i<=n ; i++) p*=i ; return p;}.
Hàm trên để tính:
{
~Tích mảng p gồm n số nguyên kiểu int.
=Tính n!.
~Hàm bị lỗi vì không khai báo kiểu trả về.
~Hàm bị lỗi vì lệnh i=2;
//------------------------------------------------------------------------

20. Cho hàm prod(int a[], int n){ int i, p=1; for (i=0 ; ip;}.
Hàm trên để tính:
{
~Tính tích mảng p gồm n số nguyên kiểu int.
=Tính tích mảng a gồm n số nguyên kiểu int.
~Hàm bị lỗi vì không khai báo kiểu trả về.
~Hàm bị lỗi vì không khai báo kích thước mảng a.
//-----------------------------------------------------------------------21. Biến toàn cục:
{
~ Khai báo bên ngoài hàm main( )
~ Khai báo trong tất cả các hàm, ngoại trừ hàm main( )
~ Khai báo bên trong hàm main( )
=Khai báo ngoài tất cả các hàm kể cả hàm main( )
}
//-------------------------------------------------------------------------------------------------22. Phạm vi sử dụng của biến toàn cục

{
~Bên trong hàm main( )
~Bên ngoài hàm main( )
~Bên trong các hàm ngoại trừ hàm main( )
=Bên trong các hàm kể cả hàm main( )
}
//-------------------------------------------------------------------------------------------------23. Phạm vi sử dụng của biến cục bộ
{
~Bên trong hàm main( )
~Bên ngoài hàm main( )
~Bên trong các hàm ngoại trừ hàm main( )
=Bên trong hàm có khai báo nó

}
//-------------------------------------------------------------------------------------------------24. Nếu tham số của hàm là con trỏ thì trong lệnh gọi hàm:
{
~Truyền hằng
~Tuyền bằng địa chỉ của biến
=Truyền bằng địa chỉ của biến hoặc con trỏ


~ Truyền biến
}
//------------------------------------------------------------------------------------------------2
25. *Hàm sau tính

long int giai_thua(int n)
{ int i; long int p=1;
for(i=2;ireturn(p);
}
{
~n !!
~p!
=(n-1)!
~n!
}
//-------------------------------------------------------------------------------------------------26. Hàm sau tính
double mu ( double a, int n)
{ double p; int i;
for(p=1,i=1;i<=abs(n);i++) p=p*a;
if(n<0) p=1/p;
return(p);

}
{
~an
~na
~Kết quả khác
=an
}
//-------------------------------------------------------------------------------------------------2
27. *Cho hàm
int kt(unsigned n)
{
if (n%2) return(1 ) ;
else return(0) ;
}
Biểu thức 1+kt(4+1) có giá trị
{
~1
~0
~6
=2


}
//-------------------------------------------------------------------------------------------------28. Hàm sau tính
double tinhs(double x,int n)
{
double s, a;
int i;
s=1;a=x;i=1;
while(i<=abs(n)){

s=s+a;
i++;
a=a*x;
}
return(s);
}
{
~ x+x2+x3+…+xn
~ x2+x3+…+xn
~Kết quả khác
=1+x+x2+x3+…+xn
}
//-------------------------------------------------------------------------------------------------29. Cho biết kết quả của chương trình sau
#include <stdio.h>
int fibo(int i);
void main( )
{
int i=5;
printf("\n So Fibonacci thu %d la %d",i,fibo(i));
}
int fibo(int i)
{
if (i<3) return(1);
else return (fibo(i-2)+fibo(i-1));
}
{
~So Fibonacci thu 5 là 8
~So Fibonacci thu 5 là 3
~Kết quả khác
=So Fibonacci thu 5 là 5

}
//-------------------------------------------------------------------------------------------------3


30. *Cho biết kết quả của chương trình sau

#include <stdio.h>
void main( )
{
unsigned n=3;
printf("\nTong cua %u so la : %u",n+1, tinhs(n));
}
unsigned tinhs(unsigned n)
{
unsigned i,s;
for(s=0,i=1;i<=2*n+1;i+=2) s=s+i;
return(s);
}
{
~Tong cua 4 so la 9
~Tong cua 3 so la 9
~Kết quả khác
=Tong cua 4 so la 16
}
//-------------------------------------------------------------------------------------------------3
31. *Biến cục bộ tĩnh

{
~Được khai báo bên trong thân hàm
~Được khai báo với từ khoá static

~Vẫn tồn tại ngay cả khi hàm kết thúc
=Tất cả đều đúng
}
//------------------------------------------------------------------------------------------------6
32. Biến con trỏ có thể chứa
{
~Giá trị của một biến
~Giá trị của một vùng nhớ
~Giá trị một biến hoặc một vùng nhớ
= Địa chỉ của một biến
}
//-------------------------------------------------------------------------------------------------6
33. Cho khai báo: int n, *pn=&n;
{
~ n là biến kiểu int
~ *pn là biến con trỏ và n là biến kiểu int


~ pn là biến con trỏ
= n là biến kiểu int và pn là biến con trỏ có giá trị đầu là địa chỉ của n .
}
//-------------------------------------------------------------------------------------------------6
34. Toán tử truy cập giá trị mà con trỏ chỉ đến là
{
~>
~.
~&
=*
}
//-------------------------------------------------------------------------------------------------3

35. *Có khai báo sau

char *str=”HELLO”;
Phép toán str++ sẽ
{
~ Tăng str lên 1 byte
~ Tăng str lên 1 char
~ str trỏ tới ký tự ‘E’
= Cả 3 đáp án trên đều đúng.
}
//------------------------------------------------------------------------------------------------6
36. *Có khai báo sau

int num[]={5,10,15,20,25};
int *ptr = &num[0];
Phép toán ptr++ sẽ
{
~ Tăng ptr lên 1 int
~ Tăng ptr lên 2 byte.
~ ptr trỏ tới num[1]
= Cả 3 đáp án trên đều đúng.
}
//-------------------------------------------------------------------------------------------------37. *Cho đoạn chương trình sau:

int num[ ]={1,3,5,7,9};
int *ptr1=&num[1];


int *ptr2=&num[3];
int n=ptr2-ptr1;

Kết quả của n là
{
~3
~4
~5
=2
}
//-------------------------------------------------------------------------------------------------38. *Chọn phát biểu đúng ?

{
~ Cách đặt tên hàm giống cách đặt tên biến.
~ Số tham số hình thức bằng số tham số thực.
~ Các tham số trong nguyên mẫu của hàm đặt cách nhau bởi dấu phẩy.
= Tất cả đều đúng.
}
//------------------------------------------------------------------------6
39. *Cho biết giá trị của biểu thức thi(6)?

int thi(int i){
return (!i%3);
}
{
=0
~1
~2
~ Hàm bị lỗi.
}
//-----------------------------------------------------------------------40. Cho biết kết quả hiển thị lên màn hình khi chạy dòng lệnh thi(5);?
int thi(int n){
for(int i=1; i

}
{
~01234
=1234


~4321
~ Lệnh gọi hàm không đúng.
}
//-----------------------------------------------------------------------41. *Cho hàm sau:

int thi(int n){
if (n==0 ) return 1;
return thi(n-1)*n;
}
Cho biết kết quả hiện lên màn hình khi thực hiện dòng lệnh printf("%o", thi(4));
{
~ 10
~ 24
= 30
~ 12
}
//-----------------------------------------------------------------------42. *Cho biết giá trị của biểu thức thi(4)+1?

int thi(int n){
if(n==0) return 0;
return thi(n-1)+n;
}
{
~0

= 11
~6
~ 15
}
//------------------------------------------------------------------------------43. *Cho hàm sau:

int thi(int x, int *y){
x*=2; *y+=1;
return x+*y;
}
Hãy cho biết kết quả hiển thị lên màn hình khi thực hiện đoạn lệnh sau:
int i=1; j=1;


printf("%d %d %d ",i,j,thi(i,&j));
{
~114
~224
=124
~214
}
//----------------------------------------------------------------------------44. *Cho hàm sau:

void thi(unsigned int n){
if(n<2) printf("%d",n);
else{thi(n/2); printf("%d",n%2);}
}
Hãy cho biết kết quả hiển thị lên màn hình khi thực hiện lệnh thi(10);?
{
~ 0101

~ 101
= 1010
~ Hàm bị lỗi
}
//----------------------------------------------------------------------------45. *Cho biết kết quả hiển thị lên màn hình khi gọi hàm thi(8);

void thi(int i){
if(i<5) printf("%d ",i);
else{thi(i-1); printf("%d ",i);}
}
{
=45678
~87654
~4567
~7654
}
//-------------------------------------------------------------------------46. *Hãy điền vào .... để hàm sau tính n!!=2*4*6*...*n với n chẵn hoặc n!!

=1*3*5*...*n với n lẻ?
int thi(unsigned int n){
if(n<=2) return n;
return ....*n;
}
{
= thi(n-2)
~ thi(n-1)
~ thi(n+2)
~ Tất cả đều sai.
}

//----------------------------------------------------------------------------47. Hãy điền vào .... để hàm sau kiểm tra n có phải là số nguyên tố hay không?
int nguyento(unsigned int n)
{ int i;
for( i=2; i<=sqrt(n); i++) if ( .... ) return 0;
return 1;
}
{
= !(n%i)
~ n%i==1
~ n%i
~ n==0
}
//-------------------------------------------------------------------------------------48. *Cho khai báo sau:

int a=5,*b=&a ;
Để truy cập đến giá trị của a có thể dùng:
{
~ &b
= *b
~b
~ Lỗi khai báo
}
//----------------------------------------------------------------------------------------49. *Cho đoạn lệnh sau:

char a,*b;
char thi(char a, char *b){
return a;
}
Hãy chọn lệnh đúng ?

{
~ thi(a,*b);
~ b=thi(65,&a);
= thi('A',&a);
~ b=thi('A',b);
}
//------------------------------------------------------------------------------------------


50. *Số nguyên dương n là số hoàn hảo nếu n bằng tổng các ước số thực sự của

n.Ví dụ 6=1+2+3. Hãy điền vào .... để hàm sau kiểm tra n có phải là số hoàn
hảo hay không?
int thi(unsigned int n){
int s=0, i;
for(i=1; iif(!(n%i)) .... ;
return n==s;
}
{
~ s+=i++
= s=s+i
~ s++
~ S+=i
}
//------------------------------------------------------------------------------------------51. Cho hàm sau:

int thi(int n){
if(n ==0) return n;
return thi(n-2)+n;

}
Hãy cho biết kết quả hiển thị lên màn hình khi thực hiện lệnh
printf("%d",thi(6));
{
~6
~ 10
= 12
~ 14
}
//--------------------------------------------------------------------------------------52. *Cho hàm sau:

int *thi(int i){
return &i;
}
Hãy cho biết kết quả hiển thị lên màn hình khi thực hiện đoạn lệnh sau:
int i=010,*a=thi(i+012); printf("%o",*a);
{
~ 20
~ 18


= 22
~ Đoạn lệnh trên bị lỗi
}
//-------------------------------------------------------------------------------------53. *Cho hàm sau:

int thi(int n){
int s=0;
do{if(n%2==0) s++; n/=2;}while(n);
return s;

}
Hãy cho biết giá trị của hàm thi(36)?
{
~2
~0
=4
~3
}
//-----------------------------------------------------------------------------------54. *Cho hàm sau:

int thi(int x, int *y){
x=*y; *y=2*x;
return x+*y;
}
Hãy cho biết kết quả hiển thị lên màn hình khi thực hiện đoạn lệnh sau:
int x=1, y=2; printf("%d, %d, %d",thi(y,&x),x,y);
{
= 3, 1, 2
~ 3, 2, 2
~ 6, 1, 4
~ 6, 1, 2
}
//------------------------------------------------------------------------------------5
55. *Cho hàm sau:

int thi(int x, int *y){
x=3; *y=4;
return x+*y;
}
Hãy cho biết kết quả hiển thị lên màn hình khi thực hiện đoạn lệnh sau:

int x=1, y=2; thi(y,&x); printf("%d, %d",x,y);
{
~ 4, 3
~ 1, 4
~ 3, 4
= 4, 2
}
//-----------------------------------------------------------------------------------56. *Cho hàm sau:


int thi(int x){
x+=035;
printf("%o",x);
return 0;
}
Hãy cho biết kết quả hiển thị lên màn hình khi thực hiện lệnh thi(054);
{
~ 089
~ 89
= 111
~ 0111
}
//------------------------------------------------------------------------------------5
57. *Cho hàm sau:
int thi(int x, int y){
return x+y;
}
Hãy cho biết kết quả hiển thị lên màn hình khi thực hiện lệnh sau:
printf("%o",thi(0xA, 012));
{

~ 024
= 24
~ 20
~ lệnh sai
}
//------------------------------------------------------------------------------------5
58. Cho biết khai báo nguyên mẫu hàm nào là không thích hợp
{
~ void funct(char x, char y);
= double funct(char x)
~ int funct( );
~ char x( );
}
//------------------------------------------------------------------------4
59. Kiểu trả về của hàm sau đây là gì ?
funct( char c, double x, float y);
{
~ char
~ double
= int
~ float
}


//-----------------------------------------------------------------------60. *Kết quả của đoạn chương trình sau là gì ?
#include <stdio.h>
void hoandoi(int *a, int *b)
{ int t=*a; *a=*b; *b=t; }
main( )
{ int a=10, b=20; hoandoi(a, b); printf("%d %d", a, b); }

{
~ 10 20
~ 20 10
= Chương trình bị lỗi
~ Kết quả khác
}
//------------------------------------------------------------------------5
61. *Kết quả của chương trình sau là gì ?

#include <stdio.h>
void hoandoi(int a, int b)
{ int t=a; t=a; a=b; b=t; }
main( )
{ int a=100, b=200; hoandoi(&a, &b); printf("%d %d", a, b);
{
~100 200
~ 200 100
= Chương trình bị lỗi
~ Kết quả khác
}
//-----------------------------------------------------------------------62. *Ưu điểm của việc dùng hàm ?

{
=Tránh dư thừa, dễ quản lý chương trình.
~ Giúp chương trình thực hiện nhanh hơn.
~ Tận dụng kỹ năng lập trình của nhiều người.
~ Tiết kiệm bộ nhớ.
}
//-----------------------------------------------------------------------63. *Phát biểu nào sau đây là sai đối với lời gọi hàm?

{
~ Tham số thực và tham số hình thức có thể trùng tên
~ Số tham số thực phải bằng số tham số hình thức
= Tham số thực và tham số hình thức phải trùng tên
~ Tham số thực có thể là biến


}
//------------------------------------------------------------------------5
64. Đối với hàm trả về giá trị kiểu float, giá trị hàm được dùng :
{
~ Trong biểu thức
~ Như câu lệnh
~ Trong hàm main( )
= Trong biểu thức hoặc như câu lệnh
}
//------------------------------------------------------------------------5
65. Đối với hàm trả về kiểu void, lệnh gọi hàm được dùng :
{
~ Trong biểu thức
= Như câu lệnh
~ Trong hàm main( )
~ Trong biểu thức hoặc như câu lệnh
}
//-----------------------------------------------------------------------66. Chọn phát biểu sai trong ngôn ngữ C:

{
~ Có thể định nghĩa hàm ở trước hàm main( )
~ Không được định nghĩa hàm trong hàm
= Có thể định nghĩa hàm trong hàm

~ Các hàm được gọi bởi hàm main( )
}
//-----------------------------------------------------------------------67. *Hàm nào sau đây là đúng cú pháp

{
~ int sum(int a, b) { return a+b; }
~ void sum(int a, int b) { return a+b;}
~ int sum(a, b) { int a,b,c; c=a+b; return c; }
= int sum(int a, int b) { return a+b; }
}
//-----------------------------------------------------------------------68. Khai báo nguyên mẫu hàm để hoán đổi 2 biến kiểu float

{
~ int

hoandoi(float *a, float b) ;


~ void hoandoi(float a, float b);
= void hoandoi(float *a, float *b) ;
~ float hoandoi(float a, float b) ;
}
//-----------------------------------------------------------------------69. *Với khai báo float a, b; float *pa, *pb;

Dãy lệnh nào dưới đây không đúng cú pháp
{
~ b=5; a=b/2; pa=&a;
~ a=10; b=a; *pb=a;
= a=b=5; pa=b;
~ a=b=5; *pa=10;

}
//-----------------------------------------------------------------------70. * Hàm dưới đây tính gì?

int tinh( unsigned a)
{ int n =0; while (a!=0) { a=a/10; n++); return n; }
{
~ Tổng các chữ số của số nguyên dương a
= Đếm số chữ số của số nguyên dương a
~ Tích các chữ số của số nguyên dương a
~ Đếm số chữ số của tự nhiên a
}
//-----------------------------------------------------------------------71. *Hàm nào dưới đây để tính n!?

{
~ long GT(int n) { long q=1; for( int i=2;i<=n; i++) q=q*i; return q; }
~ long GT(int n) { if (n==0) return 1; else return n*GT(n-1); }
~ void GT(int n, long *q) { long s=1; for( int i=2;i<=n; i++) s=s*i; *q=s; }
= Tất cả đều đúng
}
//-----------------------------------------------------------------------72. Cho biết dãy fibonanci như sau: 1 1 2 3 5 8 13 21 34 …
Hàm dưới đây có ý nghĩa là gi`?
int fibo(int n)
{ if (n==1|| n==2) return 1; else return fibo(n-1) + fibo(n-2); }
{
= Tính số fibonanci thứ n
~ Kiểm tra số n có phải là số fibonanci?
~ Tìm dãy n số fibonanci đầu tiên


~ Tất cả đều sai

}
//-----------------------------------------------------------------------73. Xét khai báo hàm như sau:
long S(int n)
{ if (n==0) return 0;
else return n*n + S(n-1);
}
Cho biết giá trị S(3)
{
~9
= 14
~ 23
~ Số khác
}
//-----------------------------------------------------------------------74. Cho hàm sau:
void myFunc (int n)
{ if (n <5) myFunc(++n); printf("%d, ", n);}
Cho biết kết quả của lệnh gọi hàm: myFunc(0);
{
~ 5, 5, 4, 3, 2, 1,
= 5, 4, 3, 2, 1,
~ 1, 2, 3, 4, 5,
~ 1, 2, 3, 4, 5, 5,
}
//-----------------------------------------------------------------------75. *Cho biết kết quả khi thực hiện chương trình sau:

#include <stdio.h>
int a,b;
void myFunc( )
{ int a=2; b=4; printf(" %d %d", a, b); }
main( )

{ a=3; b=6; printf(" %d %d", a, b);
myFunc( ); printf(" %d %d", a, b);
}


{
~
~
=
~

362436
362426
362434
Kết quả khác

}
//-----------------------------------------------------------------------76. *Cho biết kết quả khi thực hiện chương trình sau:

#include <stdio.h>
int a,b;
void myFunc()
{ int a,b; a=2; b=4; printf(" %d %d", a, b); }
main( )
{ a=3; b=6; printf(" %d %d", a, b);
myFunc(); printf(" %d %d", a, b);
}
{
=
~

~
~

362436
362426
362434
362424

}
//-----------------------------------------------------------------------77. *Hãy điền vào chỗ # và ## để hàm sau kiểm tra số n có phải là số nguyên tố ?

int nguyento( unsigned n)
{ int i;
for(i=2; i <= #; i++) if (##) return 0;
return 1;
}
{
~ n và n%i ==0
~ n/2 và n%i !=0
~ n/2 và n%i =0
= sqrt(n) và n%i==0
}
//------------------------------------------------------------------------


78. *Các phép toán trên con trỏ ?

{
~ Nhân, chia
~ Nhân, chia, cộng, trừ

~ Chia
= Cộng, trừ
}
//-----------------------------------------------------------------------79. *Xét khai báo sau

int a[100], *pa;
pa=a;
{
~ pa là giá trị của mảng a
= pa chứa địa chỉ của a[0]
~ pa là giá trị đầu tiên của mảng a
~ Khai báo không hợp lệ
}
//-----------------------------------------------------------------------80. Cho khai báo:
int n=5, *pi=&n;
biểu thức ( *pi +1)*2 có giá trị:
{
~5
~6
= 12
~ 10
}
//-----------------------------------------------------------------------81. *Cho khai báo: int a,*p;

Hãy chỉ ra biểu thức không hợp lệ
{


~ *p=a
~ *p= =a

~ *p+1= =a
= *p +1 =a
}
//------------------------------------------------------------------------

82. *Cho đoạn mã sau

char *s, t[25]; //1
t=" Khoa cong nghe thong tin"; //2
gets(s); //3
Hãy chọn đáp án đúng
{
= Lỗi dòng 2
~ Lỗi dòng 3
~ Lỗi dòng 2 và 3
~ Không lỗi dòng nào
}
//-----------------------------------------------------------------------83. *Hàm sau làm gì ?

void thihocky(int *a, int &n)
{
int i;
for(i=0; i--n;
}
{
~ Xóa mảng a
= Loại phần tử đầu tiên ra khỏi mảng a
~ Giảm số phần tử của mảng a
~ Loại phần tử cuối cùng ra khỏi mảng a

}
//-----------------------------------------------------------------------84. *Hàm sau làm gì ?

void thitinhocdaicuong(int *a, int &n, int k)


{
int i;
for(i=k; ia[i]=a[i+1];
--n;
}

{
= Loại phần tử thứ k của mảng a
~ Loại phần tử thứ nhất của mảng a
~ Kiểm tra k có trong mảng a hay không
~ Giảm số phần tử của mảng a
}
//-----------------------------------------------------------------------85. *Giả sử có mảng một chiều a gồm n phần tử. Hàm sau làm gì ?

void thitracnghiem(int *a, int &n, int x)
{
a[n]=x;
n++;
}
{
~ Gán phần tử a[n]=x
= Thêm phần tử x vào cuối mảng a
~ Loại phần tử thứ n

~ Thêm phần tử n vào cuối mảng a.
}
//-----------------------------------------------------------------------86. *Giả sử có mảng một chiều a gồm n phần tử là số nguyên. Hàm sau làm gì ?

void tinhco(int *a, int &n, int x, int k)
{ int i;
for(i=n; i>k; i--) a[i]=a[i-1];
a[k]=x;
n++;
}
{
~ Chèn phần tử k vào vị trí x của mảng a