Cho số nguyên dương N. Hãy khai báo một vector số nguyên lưu trữ N phần tử được nhập từ bàn phím. Sau đó, in các phần tử của vector ra màn hình trên một dòng, cách nhau bởi dấu cách.

Input:

• Dòng 1: Số nguyên N.

• Dòng 2: N số nguyên A[i].

Ràng buộc:

• 1 <= N <= 10^5

• -10^9 <= A[i] <= 10^9

Output:

• In ra các phần tử của vector.

Ví dụ 1:

Input:

5
1 2 3 4 5

Output:

1 2 3 4 5

Ví dụ 2:

Input:

3
10 -20 30

Output:

10 -20 30

Cho vector A gồm N số nguyên. Hãy in ra các phần tử của vector theo thứ tự ngược lại (từ cuối về đầu).

Input:

• Dòng 1: Số nguyên N.

• Dòng 2: N số nguyên A[i].

Ràng buộc:

• 1 <= N <= 10^5

• -10^9 <= A[i] <= 10^9

Output:

• Dãy số sau khi đảo ngược.

Ví dụ 1:

Input:

4
1 2 3 4

Output:

4 3 2 1

Ví dụ 2:

Input:

3
5 5 1

Output:

1 5 5

Cho vector A gồm N phần tử. Hãy in ra giá trị của phần tử ở vị trí thứ K (tính từ 0). Nếu K nằm ngoài phạm vi của vector (nhỏ hơn 0 hoặc lớn hơn N-1), hãy in ra -1.

Input:

• Dòng 1: Hai số nguyên N và K.

• Dòng 2: N số nguyên A[i].

Ràng buộc:

• 1 <= N <= 10^5

• -10^5 <= K <= 10^5

• |A[i]| <= 10^9

Output:

• Giá trị phần tử tại vị trí K hoặc -1.

Ví dụ 1:

Input:

5 2
10 20 30 40 50

Output:

30

Ví dụ 2:

Input:

3 5
1 2 3

Output:

-1

Cho vector A gồm N số nguyên. Hãy tính tổng tất cả các phần tử có trong vector.

Input:

• Dòng 1: N.

• Dòng 2: N số nguyên A[i].

Ràng buộc:

• 1 <= N <= 10^5

• |A[i]| <= 10^9 (Lưu ý kết quả có thể vượt quá int).

Output:

• Tổng các phần tử.

Ví dụ 1:

Input:

4
1 2 3 4

Output:

10

Ví dụ 2:

Input:

3
1000000000 1000000000 1000000000

Output:

3000000000

Cho vector A gồm N phần tử. Hãy xóa phần tử tại vị trí K (tính từ 0).

Sau khi xóa, các phần tử phía sau sẽ dồn lên trước.

Input:

• Dòng 1: N.

• Dòng 2: N số nguyên A[i].

• Dòng 3: Số nguyên K (0 <= K < N).

Ràng buộc:

• 1 <= N <= 1000

• |A[i]| <= 10^9

Output:

• Vector sau khi xóa.

Ví dụ 1:

Input:

5
10 20 30 40 50
2

Output:

10 20 40 50

Ví dụ 2:

Input:

3
1 2 3
0

Output:

2 3

Cho vector A gồm N phần tử.

Hãy xóa tất cả các phần tử từ chỉ số L đến chỉ số R (bao gồm cả L và R).

Input:

• Dòng 1: N.

• Dòng 2: N số nguyên A[i].

• Dòng 3: Hai số nguyên L, R (0 <= L <= R < N).

Ràng buộc:

• 1 <= N <= 1000

• |A[i]| <= 10^9

Output:

• Vector sau khi xóa.

Ví dụ 1:

Input:

6
1 2 3 4 5 6
2 4

Output:

1 2 6

Ví dụ 2:

Input:

4
10 20 30 40
0 3

Output:

(Dòng này để trống)

Cho vector A. Tìm giá trị lớn nhất và vị trí xuất hiện đầu tiên của nó trong vector.

Input:

• Dòng 1: N.

• Dòng 2: N số nguyên A[i].

Ràng buộc:

• 1 <= N <= 10^5

• |A[i]| <= 10^9

Output:

• Giá trị lớn nhất và chỉ số của nó.

Ví dụ 1:

Input:

5
1 5 3 5 2

Output:

5 1

Ví dụ 2:

Input:

3
-1 -5 -2

Output:

-1 0

Cho vector A và số nguyên X. Hãy đếm xem X xuất hiện bao nhiêu lần trong vector.

Input:

• Dòng 1: N và X.

• Dòng 2: N số nguyên A[i].

Ràng buộc:

• 1 <= N <= 10^5

• |A[i]|, |X| <= 10^9

Output:

• Số lần xuất hiện của X.

Ví dụ 1:

Input:

6 2
1 2 3 2 4 2

Output:

3

Ví dụ 2:

Input:

5 10
1 2 3 4 5

Output:

0

Cho vector A gồm N số nguyên.

Hãy tạo một vector B mới, chỉ chứa các số Chẵn từ vector A theo thứ tự xuất hiện.

In ra vector B.

Input:

• Dòng 1: N.

• Dòng 2: N số nguyên A[i].

Ràng buộc:

• 1 <= N <= 10^5

• |A[i]| <= 10^9

Output:

• Các phần tử của vector B.

Ví dụ 1:

Input:

5
1 2 3 4 6

Output:

2 4 6

Ví dụ 2:

Input:

3
1 3 5

Output:

(Dòng này để trống)

Cho vector A. Kiểm tra xem vector này có phải là dãy tăng dần (A[i] <= A[i+1]) hay không.

In "YES" nếu đúng, "NO" nếu sai.

Input:

• Dòng 1: N.

• Dòng 2: N số nguyên A[i].

Ràng buộc:

• 2 <= N <= 10^5

• |A[i]| <= 10^9

Output:

• YES hoặc NO.

Ví dụ 1:

Input:

4
1 2 5 9

Output:

YES

Ví dụ 2:

Input:

4
1 3 2 4

Output:

NO

Cho vector A. Hãy thay thế tất cả các số có giá trị X thành giá trị Y.

Input:

• Dòng 1: N.

• Dòng 2: N số nguyên A[i].

• Dòng 3: Hai số nguyên X và Y.

Ràng buộc:

• 1 <= N <= 10^5

• |A[i]|, |X|, |Y| <= 10^9

Output:

• Vector sau khi thay thế.

Ví dụ 1:

Input:

5
1 2 1 3 1
1 0

Output:

0 2 0 3 0

Ví dụ 2:

Input:

3
5 5 5
2 4

Output:

5 5 5

Cho vector A. Hãy sắp xếp vector này theo thứ tự tăng dần và in ra. (Gợi ý: Sử dụng sort trong thư viện algorithm).

Input:

• Dòng 1: N.
• Dòng 2: N số nguyên A[i].

Ràng buộc:

• 1 <= N <= 10^5
• |A[i]| <= 10^9

Output:

• Vector sau khi sắp xếp.

Ví dụ 1:

Input:

5
5 1 4 2 8

Output:

1 2 4 5 8

Ví dụ 2:

Input:

3
3 2 1

Output:

1 2 3

Cho hai vector A (kích thước N) và B (kích thước M). Hãy tạo vector C là kết quả của việc nối vector B vào sau vector A.

Input:

• Dòng 1: N và M.
• Dòng 2: N số nguyên của A.
• Dòng 3: M số nguyên của B.

Ràng buộc:

• 1 <= N, M <= 1000
• |Giá trị| <= 10^9

Output:

• Vector C.

Ví dụ 1:

Input:

3 2
1 2 3
4 5

Output:

1 2 3 4 5

Ví dụ 2:

Input:

2 2
10 20
30 40

Output:

10 20 30 40

Cho vector A gồm N phần tử.

Hãy chèn giá trị X vào vị trí K (tính từ 0) trong vector.

Các phần tử từ vị trí K trở về sau sẽ bị đẩy lùi lại.

Input:

• Dòng 1: N.

• Dòng 2: N số nguyên A[i].

• Dòng 3: Hai số nguyên K và X. (0 <= K <= N).

Ràng buộc:

• 1 <= N <= 1000

• |A[i]|, |X| <= 10^9

Output:

• Vector sau khi chèn.

Ví dụ 1:

Input:

4
1 2 3 4
1 100

Output:

1 100 2 3 4

Ví dụ 2:

Input:

3
5 5 5
3 10

Output:

5 5 5 10

Ban đầu có một vector rỗng.

Bạn sẽ nhận được Q thao tác. Mỗi thao tác có dạng:

• 1 X: Thêm số nguyên X vào cuối vector (push_back).

• 2: Xóa phần tử cuối cùng khỏi vector (pop_back). Nếu vector rỗng thì không làm gì.

Cuối cùng, hãy in ra kích thước hiện tại của vector và các phần tử trong đó.

Input:

• Dòng 1: Số nguyên Q (số lượng thao tác).

• Q dòng tiếp theo: Mô tả thao tác như đề bài.

Ràng buộc:

• 1 <= Q <= 1000

• |X| <= 10^9

Output:

• Dòng 1: Kích thước vector.

• Dòng 2: Các phần tử trong vector (nếu có).

Ví dụ 1:

Input:

5
1 10
1 20
2
1 30
1 40

Output:

3
10 30 40

Ví dụ 2:

Input:

3
2
1 5
2

Output:

0

(Dòng này để trống)