---
# System prepended metadata

title: Task_03

---

# Task_03
## Phần 3: Hàm trong C
### 1. Một số hàm trong thư viện math
- Hàm lượng giác sin, cos,...
cú pháp:
```
double sin (double x);
float sin (float x);
long double sin (long double x);
```
vd:
```
#include <math.h>
#include <stdio.h>
const float pi = 3.14;
int main(){
	int d = 45;
	printf("sin(%d) = %f", d, sin(45 * pi /180));
} 
```
- Hàm exp()- tính e^x
Cú pháp:
```
double exp (double x);
float exp (float x);
long double exp (long double x);
```
vd:
```
#include <math.h>
#include <stdio.h>
int main ()
{
  double param, result;
  param = 2.0;
  result = exp (param);
  printf ("e^%f = %.2f.\n", param, result );
  return 0;
}
```
- Hàm logarit – log()
Cú pháp:
```
double log (double x);
float log (float x);
long double log (long double x);
```
Vd:
```
#include <math.h>
#include <stdio.h>
int main ()
{
  double param, result;
  param = 2;
  result = log (param);
  printf ("log(%f) = %f\n", param, result );
  return 0;
}
```
- Hàm pow() – Tính lũy thừa ab
Cú pháp:
```
double pow (double base     , double exponent);
float pow (float base      , float exponent);
long double pow (long double base, long double exponent);
```
Vd:
```
#include <math.h>
#include <stdio.h>
int main ()
{
  printf ("2 ^ 3 = %f\n", pow (2.0, 3.0) );

  return 0;
}
```
- Hàm sqrt() – Tính căn bậc 2
Cú pháp:
```
double sqrt (double x);
float sqrt (float x);
long double sqrt (long double x);
```
Vd:
```
#include <math.h>
#include <stdio.h>
int main ()
{
  double param, result;
  param = 64.0;
  result = sqrt (param);
  printf ("sqrt(%f) = %f\n", param, result );
  return 0;
}
```
- Hàm abs() và fabs() – Tìm trị tuyệt đối
Hàm abs() thương được dùng để tìm trị tuyệt đối của số nguyên, còn hàm fabs() để tìm trị tuyệt đối của số thực.
vd:
```
#include <math.h>
#include <stdio.h>
int main ()
{
  printf ("\nThe absolute value of 3.1416 is %f\n", fabs (2.11) );
  printf ("\nThe absolute value of -10.6 is %f\n", fabs (-5.2) );
 
  printf ("\nThe absolute value of 3 is %d\n", abs (3) );
  printf ("\nThe absolute value of -10 is %d\n", abs (-10) );
  return 0;
}
```
 
 ### 2. Hàm trả về
 vd:hàm trả về tổng của các số
 ```
 #include<iostream>

using namespace std;
	for (int i = 1; i <= n; i++) {
		add += i;
	}
int main() {
	cout << sum(3) << " " << sum(4) << " " << sum(5);
	return 0;
}
```
 ### 3. Hàm không trả về giá trị
 vd:in ra chữ "lập trình không khó" với số lần lặp là n lần
 ```
 #include <stdio.h>
 
void Print(int time){
    for(int i = 0; i < time; i++){
        printf("\nLap trinh khong kho!");
    }
}
```
### 4. Lệnh return và exit
- Lệnh return
    - được sử dụng để trả về một giá trị nào đó hoặc chỉ đơn giản là chuyển điều khiển cho hàm gọi
    -  sẽ thoát khỏi hàm ngay khi hàm gặp nó và tiếp tục quay lại thực thi các dòng mã sau lời gọi hàm (nếu có).
vd:
```
#include<stdio.h>
void xeploai(int diem)
{
    if(diem >= 9)
    {
        printf("Hoc sinh gioi");
        return;
    }
    else if(diem >= 7 )
    {
        printf("Hoc sinh kha");
        return;
    }
    else
    {
        printf("Hoc sinh trung binh");
        return;
    }
}
int main()
{
    int diem;
    printf("Nhap diem: ");
    scanf("%d", &diem);
    xeploai(diem);
}
```
=> nhập điểm bằng 9 sẽ thỏa mãn điều kiện diem >= 9 trong if thì sau đó thực hiện in ra màn hình “Hoc sinh gioi” và khi gặp câu lệnh return để trả về kết quả cho hàm xeploai() khi được gọi trong hàm main, return này cũng làm cho các câu lệnh if ở dưới không được thực thi nữa
- Lệnh exit
    - được sử dụng để thoát khỏi chương trình. Khi được triệu gọi sẽ ngay lập tức kết thúc chương trình và chuyển quyền điều khiển cho hệ điều hành.
vd:
```
#include <stdio.h>
#include <stdlib.h>

int main ()
{
   printf("Bat dau thuc thi chuong trinh ...\n");
   
   printf("Thoat chuong trinh ...\n");
   exit(0);

   printf("Ket thuc chuong trinh ...\n");

   return(0);
}
```
### 5. Mảng 1 chiều
- Mảng là một tập hợp tuần tự các phần tử có cùng kiểu dữ liệu và các phần tử được lưu trữ trong một dãy các ô nhớ liên tục trên bộ nhớ. Các phần tử của mảng được truy cập bằng cách sử dụng chỉ số. Mảng có kích thước N sẽ có chỉ số từ 0 tới N-1.
- Cú pháp khai báo mảng 1 chiều
    - Kích thước của mảng: Việc này xác định số lượng phần tử có thể được lưu trữ trong mảng.
    - Kiểu dữ liệu của mảng: Việc này chỉ định kiểu dữ liệu của các phần tử trong mảng; là số nguyên, số thực, ký tự hay là kiểu dữ liệu nào đó.
vd:
```
int arr[3] = {4, 12, 7};
```
- thao tác với mảng 1 chiều
    -  nhập mảng 1 chiều
vd:
```
#include <stdio.h>
void Nhap(int a[], int n){
    for(int i = 0; i <= n - 1; i++){
        printf("NHAP A[%d]: ",i);
        scanf("%d",&a[i]);
    }
}
int main(){
    int n;
    printf("NHAP VAO N PHAN TU: ");
    scanf("%d",&n);
    int a[n];
    Nhap(a,n);
}
```
- xuất mảng 1 chiều
```
void XuatMang(int a[], int n){
    for(int i = 0;i < n; ++i){
        printf("\nPhan tu a[%d] = %d", i, a[i]);
    }
}
```
- tìm kiếm trong mảng 1 chiều
```
int TimKiem(int a[], int n, int v){
    for(int i = 0;i < n; ++i){
        if(a[i] == v){
            return i;
        }
    }
    return -1;
}
 ```
## *Một số bài tập về mảng 1 chiều
- tính tổng các số trong mảng theo chẵn, lẻ
```
#include <stdio.h>
 
const int MAX_SIZE = 100;
 
void NhapMang(int a[], int n)
{
    for (int i = 0; i < n; i++)
    {
        printf("a[%d] = ", i);
        scanf("%d", &a[i]);
    }
}
 
void XuatMang(int a[], int n)
{
    for (int i = 0; i < n; i++)
    {
        printf("%5d", a[i]);
    }
}
int SumOdd(int a[], int n)
{
    int sum = 0;
    for (int i = 0; i < n; i++)
    {
        if (a[i] % 2 != 0)
        {
            sum += a[i];
        }
    }
    return sum;
}
 
int SumEven(int a[], int n)
{
    int sum = 0;
    for (int i = 0; i < n; i++)
    {
        if (a[i] % 2 != 0)
        {
            continue;
        }
        sum += a[i];
    }
    return sum;
}
 
int main()
{
    int arr[MAX_SIZE];
 
    int n; 
  
    do
    {
        printf("Nhap n = ");
        scanf("%d", &n);
    } while (n <= 0 || n > MAX_SIZE);
 
    NhapMang(arr, n);

    XuatMang(arr, n);
 
    printf("\nTong so le = %d", SumOdd(arr, n));
    printf("\nTong so chan = %d", SumEven(arr, n));
}
```
- xuất ra số lớn nhất, nhỏ nhất trong mảng
```

#include <stdio.h>
 
void nhap(int a[], int n)
{
    for (int i = 0; i < n; i++)
    {
        printf("Nhap vao phan tu a[%d]: ", i);
        scanf("%d", &a[i]);
    }
}
int max(int a[], int n)
{
    int max = a[0];
    for (int i = 1; i < n; i++)
        if (max < a[i])
            max = a[i];
    return max;
}
 
int min(int a[], int n)
{
    int min = a[0];
    for (int i = 1; i < n; i++)
        if (min > a[i])
            min = a[i];
    return min;
}
int main()
{
    int a[1000];
    int n;
    printf("\nNhap n = ");
    scanf("%d", &n);
    nhap(a, n);
    printf("\nMax = %d", max(a, n));
    printf("\nMin = %d", min(a, n));
    return 0;
}
```
## challage
### chall_01
```
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){
	int a[30]= {75, 67, 83, 67, 123, 87, 104, 97, 116, 95, 73, 115, 95, 79, 99, 116, 97, 108, 63, 125}; 
	int i=0;
	while (i<30)
	{
		printf("%c",a[i]);
		i++;
	}
	return 0;
}
```
kq:![](https://i.imgur.com/uOQ6FiI.png)


 
### chall_02
```
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
 
int Oct2Dec(int number){
    int p = 0;
    int decNumber = 0;
    while(number > 0){
        decNumber += (number % 10) * pow(8, p);
        p++;
        number /= 10;
    }
    return decNumber;
}
 
//int main(){
//    int octNumber;
//    printf("\nNhap so o co so 8: ");
//    scanf("%d", &octNumber);
// 
//    printf("\nDec = %d", Oct2Dec(octNumber));
//}
int main(int argc, char *argv[]){
	int a[30]= {113, 103, 123, 103, 173, 127, 150, 141, 164, 137, 111, 163, 137, 117, 143, 164, 141, 154, 77, 175}; 
	int i=0;
	while (i<30)
	{
		printf("%c",Oct2Dec(a[i]));
		i++;
	}
	return 0;
}
```
kq:![](https://i.imgur.com/8L13IOP.png)
### chall_03
```
#include <stdio.h>
#include <math.h>
#include <stdlib.h>


int BinToDec(long long a)
{
    int p = 0;
    int n = 0;
    while (a > 0)
    {
        n += (a % 10) * pow(2, p);
        p=p+1;
        a /= 10;
    }
//    printf("%d\n",n);
    return n;
}



int main(int argc, char *argv[]){
//	int a[50]= {01001011, 01000011, 01010011, 01000011, 01111011, 01101000, 01110100, 01110100, 01110000, 01110011, 00111010, 00101111, 00101111, 01110111, 01110111, 01110111, 00101110, 01111001, 01101111, 01110101, 01110100, 01110101, 01100010, 01100101, 00101110, 01100011, 01101111, 01101101, 00101111, 01110111, 01100001, 01110100, 01100011, 01101000, 00111111, 01110110, 00111101, 01001110, 01001100, 01000010, 01010100, 01100010, 01000011, 01100110, 01010010, 00101101, 01000110, 01100111, 01111101}; 
	long long a[50]= {1001011, 1000011, 1010011, 1000011, 1111011, 1101000, 1110100, 1110100, 1110000, 1110011, 111010, 101111, 101111, 1110111, 1110111, 1110111, 101110, 1111001, 1101111, 1110101, 1110100, 1110101, 1100010, 1100101, 101110, 1100011, 1101111, 1101101, 101111, 1110111, 1100001, 1110100, 1100011, 1101000, 111111, 1110110, 111101, 1001110, 1001100, 1000010, 1010100, 1100010, 1000011, 1100110, 1010010, 101101, 1000110, 1100111, 1111101}; 
	
	int i=0;
	while (i<50)
	{
		printf("%c",BinToDec((int)a[i]));
//		BinToDec(a[i]);
		i++;
	}
	return 0;
```
kq:![](https://i.imgur.com/nE0lQzP.png)
### chall_04
```
c="4b 43 53 43 7b 68 74 74 70 73 3a 2f 2f 77 77 77 2e 79 6f 75 74 75 62 65 2e 63 6f 6d 2f 77 61 74 63 68 3f 76 3d 4f 59 55 59 37 55 67 75 70 74 73 7d"
c=c.split(" ")
a=[]
for i in c:
	b=int(i,16)
	a.append(b)
print (a)
flag=""
for i in range(len(a)):
	flag=flag+chr(a[i])
print(flag) 
```
![](https://i.imgur.com/UMexwYr.png)
### chall_05
- ngăn cách lần lượt 81 phần tử bằng dấy phẩy.
- tách thành chuỗi bằng kí tự ","
- chuyển các chuỗi đã tách từ hệ 16 sang hệ kí tự với hex encode 5 lần dung vòng lặp for.