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 đã được sắp xếp tăng dần. Hãy xóa các phần tử trùng lặp sao cho mỗi giá trị chỉ xuất hiện đúng 1 lần. In ra vector sau khi xử lý.

Input:

• Dòng 1: N.
• Dòng 2: N số nguyên A[i] (đã sắp xếp).

Ràng buộc:

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

Output:

• Vector kết quả.

Ví dụ 1:

Input:

6
1 1 2 2 3 4

Output:

1 2 3 4

Ví dụ 2:

Input:

3
5 5 5

Output:

5

Cho mảng số nguyên A gồm N phần tử là một cấp số cộng. Nhập N và giá trị cho 2 phần tử đầu tiên của mảng từ bàn phím. Dựa vào hai giá trị đầu, hãy tính giá trị cho các phần tử còn lại của mảng.

In ra màn hình dãy số số vừa tạo.

Ràng buộc:

• Giới hạn thời gian: 1 giây

• Giới hạn bộ nhớ: 256 MB

• Dữ liệu vào:

• Một dòng duy nhất chứa 3 số nguyên: N, A[O], A[1].

• 1 ≤ N < 10^5

• -10^9 ≤ A[0], A[1] ≤ 10^9.

Ví dụ:

Input:

5 4 6

Output:

4 6 8 10 12

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

Cho vector A gồm N phần tử. Nếu tổng các phần tử của vector là số Lẻ, hãy xóa sạch vector (dùng lệnh clear). Nếu tổng là số Chẵn, giữ nguyên vector. In ra số lượng phần tử còn lại trong vector.

Input:

• Dòng 1: N.

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

Ràng buộc:

• 1 <= N <= 1000

• 0 <= A[i] <= 1000

Output:

• Số lượng phần tử còn lại.

Ví dụ 1:

Input:

3
1 2 4

Output:

0

(Giải thích: Tổng = 7 là số lẻ -> xóa hết)

Ví dụ 2:

Input:

2
5 5

Output:

2

(Giải thích: Tổng = 10 là số chẵn -> giữ nguyên)

Cho vector A gồm N phần tử ban đầu toàn số 0. Sau đó, người ta thay đổi M giá trị đầu tiên thành các số 1. Nếu M > N, vector sẽ tự động mở rộng thêm để chứa đủ M số 1. Hãy in ra kích thước vector sau cùng và các phần tử của nó.

Input:

• Hai số nguyên N và M.

Ràng buộc:

• 1 <= N, M <= 1000

Output:

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

• Dòng 2: Các phần tử.

Ví dụ 1:

Input:

5 3

Output:

5
1 1 1 0 0

Ví dụ 2:

Input:

3 5

Output:

5
1 1 1 1 1

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)