Ma so sinh vien: 23020075

Ten sinh vien: Hà Mạnh Hùng

Bai 1:
#include <iostream>
using namespace std;
void f(int* a) {
cout << sizeof(a) << endl;
}
int main() {
int A[]= {1,2,3,4,5,6,7,8,9,10};
cout << sizeof(A) << endl;
f(A);
return 0;
}

Bài 2:
#include <iostream>

using namespace std;

int count_event(int* a, int n) {

int dem = 0;
for (int i = 0; i < n; i++) {
if (a[i] % 2 == 0) {
dem++;
}
}
return dem;
}

int main() {
int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int k = sizeof(A) / sizeof(A[0]);
cout << count_event(A, 5) << " " << count_event(A + k -
5, 5);
 return 0;
}

Bài 3:
#include <iostream>
using namespace std;

bool binary_search(int* a, int siz, int res) {

int l = 0;
int r = siz - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (res == a[mid]) {
return true;
} else if (res < a[mid]) {
r = mid - 1;
} else {
l = mid + 1;
}
}
return false;
}

int main() {
int A[] = {1, 3, 5, 7, 9, 10, 13, 14, 18, 21};
int k = sizeof(A) / sizeof(A[0]);
int result = 10;
if (binary_search(A, k, result)) {
cout << result << " " << "YES" << endl;
} else {
cout << result << " " << "NO" << endl;
}
return 0;
}
Bài 4:
#include <iostream>
#include <string>
using namespace std;

char* weird_string() {
char c[] = "12345";
return c;
}

int main() {
char* p = weird_string();
cout << p << endl;
return 0;
}
- Cảnh báo: việc trả về địa chỉ một biến.
- Đầu ra: không dự đoán được và lỗi vùng bộ nhớ không hợp
lệ.

Bài 5:
- test-cmd sẽ in ra số lượng tham số là 1 và giá trị của
tham số đó là tên chương trình test-cmd
- test-cmd first second 3rd: in ra số lượng tham số là 4
và giá trị của chúng
- test-cmd 1: in ra số lượng tham số là 2 và giá trị của
chúng
- domin 1 2 3: in ra số lượng tham số là 4 và giá trị của
chúng

Bài 6:
#include <bits/stdc++.h>
using namespace std;

int main(int argc, char* argv[]) {

 if (argc < 3) {
cout << "Nhap 2 xau ky tu: <str1> <str2>" << endl;;
return 1;
}

char* str1 = argv[1];

char* str2 = argv[2];
int count = 0;

for (int i = 0; i <= strlen(str2) - strlen(str1); ++i)

{
if (strncmp(str1, str2 + i, strlen(str1)) == 0) {
count++;
}
}

cout << "Xau " << str1 << " xuat hien " << count << "
lan trong xau " << str2 << endl;

return 0;
}

Bài 7:
#include <bits/stdc++.h>
using namespace std;
char* concat(const char* str1, const char* str2) {
char* result = new char[strlen(str1)+strlen(str2) + 1];
strcpy(res, str1);
strcat(res, str2);
return res;
}

int main() {
const char* str1 = "Hello";
 const char* str2 = "World";
char* res = concat(str1, str2);
cout << res << endl;
return 0;
}

Bai 8:
Do con trỏ p2 cùng chỉ đến ô nhớ của p, sau khi delete p
thì vùng nhớ của p2 cũng biến mất:
int* p = new int;
int* p2 = p;
*p = 10;
delete p; //giải phóng con trỏ p2
p2 = nullptr; // hoặc p2 0 new int;
*p2 = 100;
cout << *p2;
delete p2;

Bai 9:
char* a = new char[10];
char* c = a + 3;
for (int i = 0; i < 9; i++) a[i] = ‘a’;
a[9] = ‘\0’;
cerr << “a: “ << “-“ << a << “-“ << endl;
cerr << “c: “ << “-“ << c << “-“ << endl;
delete c; // Lỗi: phải giải phóng vùng nhớ của a vì a mới
là vùng nhớ được cấp phát bởi new
cerr < “a after deleting c: “ << “-“ << a << “-“ << endl;
// lệnh này chạy sai
Bài 10:
#include <iostream>
using namespace std;

int main() {
int* ptr = new int; // cap phat bo nho dong
 int a = 11; // khai bao 1 bien va gan gia tri
pointer = &a; // gan dia chi cua bien cho con tro
delete ptr; // giai phong bo nho ma con tro tro den
cout << a; // truy cap bien ma con tro tro den
return 0; // lỗi vì giải phóng bộ nhớ trước khi in ra
biến
}

Trắc nghiệm:
Cau 1: iii
Cau 2: iii
Cau 3: i
Cau 4: iii
Cau 5: ii; iii
Cau 6: iii
Cau 7: iii
Cau 8: iv
Cau 9: ii
Cau 10: iv
Cau 11: iii
Cau 12: iii
Cau 13: ii; iv

C: bai tap hackerrank

Bai 1:
SinglyLinkedListNode*
removeDuplicates(SinglyLinkedListNode* llist) {
unordered_set<int> unst;
SinglyLinkedListNode* current = llist;
SinglyLinkedListNode* prev = nullptr;

while (current != nullptr) {

if (unst.find(current->data) != unst.end()) {
if (prev != nullptr) {
prev->next = current->next;
 delete current;
current = prev->next;
}
else {
SinglyLinkedListNode* tmp = llist;
llist = llist->next;
delete tmp;
current = llist;
}
}
else {
unst.insert(current->data);
prev = current;
current = current->next;
}
}

return llist;
}

Bai 2:
bool has_cycle(SinglyLinkedListNode* head) {
SinglyLinkedListNode* slow = head;
SinglyLinkedListNode* fast = head;
while (fast && fast->next) {
slow = slow->next;
fast = fast->next->next;
if (slow == fast) {
return true;
}
}
return false;
}

Bai 3:
int findMergeNode(SinglyLinkedListNode* prev,
SinglyLinkedListNode* head) {
unordered_set<SinglyLinkedListNode*> unst;

SinglyLinkedListNode* current = prev;

while (current != nullptr) {
unst.insert(current);
current = current->next;
}
current = head;
while (current != nullptr) {
if (unst.find(current) != unst.end()) {
return current->data;
}
current = current->next;
}
return -1;
}
Bai 4
DoublyLinkedListNode* sortedInsert(DoublyLinkedListNode*
llist, int data) {
DoublyLinkedListNode* newNode = new
DoublyLinkedListNode(data);
if (llist == nullptr || data <= llist->data) {
return newNode;
}
DoublyLinkedListNode* current = llist;
while (current->next != nullptr && current->next->data
< data) {
current = current->next;
}
newNode->next = current->next;
if (current->next != nullptr) {
current->next->prev = newNode;
}
current->next = newNode;
 newNode->prev = current;
return llist;
}

Bai 5:
DoublyLinkedListNode* reverse(DoublyLinkedListNode* llist){
DoublyLinkedListNode* p1 = llist;
DoublyLinkedListNode* p2 = nullptr;
while (p1 != nullptr) {
p2 = p1;
p1 = p1->next;
p2->next = p2->prev;
p2->prev = p1;
}
llist = p2;
return llist;
}