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. 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 một dãy A gồm n số nguyên a1, a2, a3, ... an và một số nguyên dương v. Hãy tìm cách xóa bỏ số a[v] khỏi dãy A, đảm bảo các số còn lại vẫn giữ nguyên thứ tự.

Input:

Dòng thứ nhất gồm hai số nguyên dương n và v (1 ≤ v ≤ n ≤ 10^5).

Dòng tiếp theo gồm n số nguyên a1, a2, a3,..., an (ai ≤ 10^5).

Output: In ra dãy n - 1 số (các số cách nhau một khoảng trắng) sau khi xoá phần tử a[v].

Sample Test

Input:

5 2
8 2 2 10 2

Output:

8 2 10 2

Cho một dãy A gồm n số nguyên a1, a2, a3, ... an và hai số nguyên v, T. Hãy tìm cách thêm số T vào vị trí v trong dãy A (các số ban đầu vẫn giữ nguyên thứ tự).

Input:

Dòng thứ nhất gồm ba số nguyên n, v, T (1 ≤ n, 1 ≤ v ≤ n+ 1 ≤ 10^5 + 1, |T| ≤ 10^5).

Dòng tiếp theo gồm n số nguyên a1, a2, a3, ..., an (|ai| ≤ 10^5).

Output: In ra dãy n + 1 số (các số cách nhau một khoảng trắng) sau khi thêm số T vào vị trí v.

Input:

5 2 9
8 6 2 10 5

Output:

8 9 6 2 10 5

Nhập 1 số nguyên dương N, sau đó nhập tiếp 1 dãy gồm N số nguyên. In ra số lượng phần tử của dãy con không giảm liên tiếp có nhiều phần tử nhất.

Input:

• Dòng đầu tiên chứa số nguyên dương N (1 ≤ N ≤ 10^6).

• Dòng tiếp theo chứa N số nguyên x (|x| ≤ 10^9).

Output: In ra số lượng phẩn tử của dãy con không giảm liên tiếp có nhiều phần tử nhất.

Input:

8
2 1 3 5 2 4 6 8

Output:

4

Nhập 1 số nguyên dương N, sau đó nhập tiếp 1 dãy gồm N số nguyên. Nhập 1 số nguyên dương K. Xóa số ở vị trí thứ K trong dãy vừa nhập. In ra dãy đó.

Input:

• Dòng đầu tiên chứa số nguyên dương N (1 ≤ N ≤ 10^6).

• Dòng tiếp theo chứa N số nguyên x (|x| ≤ 10^9).

• Dòng cuối chứa số nguyên dương K (1 ≤ K ≤ N).

Output: In ra dãy mới.

Input:

4
1 7 5 10
2

Output:

1 5 10

Nhập 1 số nguyên dương N, sau đó nhập tiếp 1 dãy gồm N số nguyên đánh số từ 1.

Nhập 2 số nguyên dương V và K. Thêm số V vào vị trí K trong dãy. In ra dãy đó.

Input:

• Dòng đầu tiên chứa số nguyên dương N (1 ≤ N ≤ 10^6).

• Dòng tiếp theo chứa N số nguyên x (|x| ≤ 10^9).

• Dòng cuối chứa 2 số nguyên dương V và K (|V| ≤ 10^9, 1 ≤ K ≤ N).

Output:

In ra dãy mới.

Ví dụ:

Input:

4
1 7 3 10
5 2

Ouptut:

1 5 7 3 10