Sereja và Dima chơi một trò chơi. Luật chơi rất đơn giản. Người chơi có n lá bài xếp thành một hàng. Mỗi lá bài có một số, tất cả các số trên các lá bài đều khác nhau. Người chơi lần lượt chơi, Sereja đi trước. Trong lượt chơi của mình, một người chơi có thể lấy một lá bài: lá bài ngoài cùng bên trái trong một hàng, hoặc lá bài ngoài cùng bên phải. Trò chơi kết thúc khi không còn lá bài nào nữa. Người chơi nào có tổng số lớn nhất trên các lá bài của mình vào cuối trò chơi sẽ thắng.

Sereja và Dima đang tham lam. Mỗi người đều chọn lá bài có số lớn hơn trong lượt đi của mình.

Inna là bạn của Sereja và Dima. Cô ấy biết chiến lược mà các chàng trai đang sử dụng, vì vậy cô ấy muốn xác định điểm số cuối cùng, dựa trên trạng thái ban đầu của trò chơi. Hãy giúp cô ấy.

Định dạng đầu vào: Dòng đầu tiên chứa số nguyên n (1 ≤  n  ≤ 1000) — số lượng thẻ trên bàn. Dòng thứ hai chứa các số cách nhau bởi dấu cách trên các thẻ từ trái sang phải. Các số trên các thẻ là các số nguyên khác nhau từ 1 đến 1000.

Định dạng đầu ra: Trên một dòng, in ra hai số nguyên. Số đầu tiên là số điểm của Sereja khi kết thúc trò chơi, số thứ hai là số điểm của Dima khi kết thúc trò chơi.

Input 01:

4 
4 1 2 10

Output 01:

12 5

Input 02:

7 
1 2 3 4 5 6 7

Output 02:

16 12

Cho mảng A[] gồm N phân tử, nhiệm vụ của bạn là xóa các phần tử trong mảng sao cho không có 2 phần tử liền kề có giá trị giống nhau. Ví dụ mảng A: = {1, 1, 2, 2, 2, 3, 3, 2, 1, 4} sau khi xóa sẽ được Al] = {1, 2, 3, 2, 1, 4}

Định dạng đầu vào:

Dòng 1 gồm N

Dòng 2 gồm N số của mảng A[]

Ràng buộc:

1<=N<=1000

0<=A[i]<=100

Định dạng đầu ra: In ra mảng sau khi xóa

Input:

11
2 3 3 0 0 0 3 3 3 3 4

Outptu:

2 3 0 3 4

Cho mảng A[] gồm N phần tử, hãy dịch các phần tử trong mảng sang trái K vị trí, khi dịch trái thì phần tử đầu tiên của dãy sẽ quay vòng lại trở thành phần tử cuối cùng.

Định dạng đầu vào:

Dòng 1 gồm N và K

Dòng 2 gõm N số của mảng A[]

Ràng buộc:

1<=N<=1000

1<=K<=1000

0<=A[i]<=100

Định dạng đầu ra: In ra mắng sau khi xoay trái

Input:

8 6
16 66 96 73 11 13 99 82

Output:

99 82 16 66 96 73 11 13

Cho mảng số nguyên A[] gồm N phần tử, nhiệm vụ của bạn là đếm xem trong mảng có bao nhiêu số chẵn, bao nhiêu số lẻ, tổng các phần tử là số chẵn, tổng các phần tử là số lẻ.

Định dạng đầu vào: Dòng đầu tiên là số nguyên dương N; Dòng thứ 2 gồm N số nguyên viết cách nhau một vài khoảng trắng.

Ràng buộc: 1<＝N<=1000; -10^3<=A|i]<=10^3

Định dạng đầu ra:

Dòng đầu tiên in ra số lượng số chắn

Dòng thứ 2 in ra số lượng số lẻ

Dòng thứ 3 in ra tống các số chẵn

Dòng thứ 4 in ra tống các số lẻ

Input

5
1 2 3 4 5

Output:

2
3
6
9

Cho mảng số nguyên A[] gồm N phần tử, tìm số lớn nhất mà mọi số trong mảng đều chia hết cho số đó.

Định dạng đầu vào: Dòng đầu tiên là số nguyên dương N; Dòng thứ 2 gồm N số nguyên viết cách nhau một vài khoảng trắng.

Ràng buộc: 1<＝N<=10^6; 0<=A[i]<=10^6

Định dạng đầu ra: In ra kết quả của bài toán

Input:

12
994626 994448 996097 995790 999692 993222 991401 999038 997163 990016 993004 990549

Output:

1

Cho mảng số nguyên A[] gồm N phần tử, tìm số lớn nhất và lớn thứ 2 trong mảng. Chú ý 2 giá trị này có thể giống nhau.

Định dạng đầu vào: Dòng đầu tiên là số nguyên dương N; dòng thứ 2 gồm N số nguyên viết cách nhau một vài khoảng trắng.

Ràng buộc: 2＜＝N<=10^6; 0<=A[i]<=10^6

Định dạng đầu ra: In ra số lớn thứ nhất và lớn thứ 2 trong mảng

Input 01:

5
1 3 2 6 3

Output 01:

6 3

Input 02:

10
5 1 100 200 4 3 6 8 100 120

Output 02:

200 120

Viết chương trình sử dụng vòng lặp for để tìm số lớn nhất trong danh sách các số nguyên nhập từ bàn phím

(Nếu code bằng Python thì mỗi số sẽ được nhập trên một dòng, cần đọc từng dòng một)

Đầu vào: Dòng thứ nhất là N là số lượng phần tử trong danh sách; dòng thứ 2 là N giá trị thuộc danh sách A

Ràng buộc: 1 <= N <= 1000; 1 <= A[i] <= 10^9

Đầu ra: In ra số lớn nhất trong danh sách

Input:

5
10 12 9 8 14

Output:

14

Nhập từ bàn phím một dãy N số nguyên vào một mảng

a) Hiện các phần tử của mảng theo thứ tự ngược lại.

b) Nhập một số nguyên dương k đếm xem trong mảng có bao nhiêu số bằng k hoặc số đối của k.

c) Nhập một số nguyên d và số nguyên dương j với 0 < j < N. Thay phần tử thứ j trong dãy bằng số d và in lại mảng.

Đầu vào: Dòng đầu tiên nhập N và k; Dòng thứ 2 nhập N số trong mảng; Dòng thứ 3 nhập d và j

Ràng buộc: ~0 \leq N, k \leq 10^6~

Input:

5 4
4 1 2 3 5
10 3

Giải thích:

Dòng đầu tiên nhập n và k

Dòng thứ 2 nhập n phần tử của mảng

Dòng thứ 3 nhập d và j

Output:

5 3 2 1 4 
1
4 1 2 10 5

Giải thích:

Dòng đầu tiên in mảng theo thứ tự ngược lại

Dòng thứ 2 in ra số lượng phần tử bằng k hoặc số đối của k

Dòng thứ 3 in ra mảng sau khi đã thay phần tử thứ j bằng d

Cho N số nguyên, bạn hãy tính tổng các số này và chia dư tổng cho ~10^9 + 7 (1000000007)~

(Lưu ý: Mỗi số trong mảng được nhập ở một dòng)

Định dạng đầu vào:

• Dòng 1 là N: số lượng số nguyên

• Dòng 2 gồm N số nguyên cách nhau 1 khoảng trắng

Ràng buộc:

~1 \leq N \leq 10^5~

Các số là nguyên dương không quá 1~0^{16}~

Định dạng đầu ra: In ra đáp án của bài toán

Input:

5
534 7 669 826 610

Output:

2646

Nhập vào một mảng A các số nguyên có N phần tử, tìm số hạng âm lớn nhất của mảng và chỉ số của nó. Nếu có nhiều số hạng âm thỏa mãn thì in ra chỉ số ở vị trí đầu tiên.

(Nếu code bằng Python thì mỗi số sẽ được nhập trên một dòng, cần đọc từng dòng một)

Dòng thứ nhất Nhập N, từ dòng thứ 2 sẽ lần lượt nhập N phần tử của mảng A

In ra phần tử âm lớn nhất và vị trí của nó trong mảng A

Ràng buộc: ~0 < N \leq 10^6, -10^6 \leq A[i] \leq 10^6~

Input 01:

9
4 -3 4 -2 -2 4 2 3 4

Output 01:

-2 4

Số âm lớn nhất ở vị trí đầu tiên là số -2 và ở vị trí thứ 4 trong mảng

Input 02:

11
4 -3 4 -2 -2 4 2 3 4 -1 -1

Output 02:

-1 10

Nhập vào một mảng A gồm các số nguyên dương có N phần tử, hãy tìm và in ra vị trí lớn nhất (bắt đầu từ 0) của phần tử nhỏ nhất và vị trí đầu tiên của phần tử lớn nhất.

(Nếu code bằng Python thì mỗi số sẽ được nhập trên một dòng, cần đọc từng dòng một)

Ràng buộc: ~0 < N \leq 10^6~; ~0 < A[i] \leq 10^6~

Dữ liệu vào gồm 2 dòng, dòng thứ nhất là số lượng N phần tử, dòng thứ 2 lần lượt là N phần tử trong mảng A.

Input:

10
5 1 4 10 3 2 1 2 3 10

Output:

1 6
10 3

Số 1 nhỏ nhất xuất hiện ở vị trí lớn nhất là 6

Số 10 lớn nhất xất hiện ở vị trí đầu tiên là 3

Nhập vào một mảng các số nguyên A có N phần tử, in ra các phần tử có giá trị bằng chỉ số của chính nó trong mảng (chỉ số tính từ 0), nếu không có thì in ra NONE. Ví dụ phần tử có giá trị là 2 ở chỉ số 2 thì bạn hãy in ra.

(Nếu code bằng Python thì mỗi số sẽ được nhập trên một dòng, cần đọc từng dòng một)

Ràng buộc: ~0 < N \leq 10^6~; ~-10^6 \leq A[i] \leq 10^6~

Dữ liệu vào gồm 2 dòng, dòng thứ nhất là số lượng N phần tử, dòng thứ 2 lần lượt là N phần tử trong mảng A.

Input 01:

10
5 1 4 3 4 -2 1 7 -3 10

Output 01:

1 3 4 7

Input 02:

10
5 2 4 4 5 -2 1 8 -3 10

Output 01:

NONE

Xây dựng hàm nhập vào ngày, tháng, năm (giả sử nhập đúng, không cần kiểm tra hợp lệ, chú ý trường hợp năm nhuận). Tính xem ngày đó là ngày thứ bao nhiêu trong năm. Ví dụ ngày 31/1/2024 là ngày thứ 31 trong năm

Input 01:

1 3 2024

Ngày 1 tháng 3 năm 2024

Output 01:

61

Là ngày thứ 61 trong năm (năm 2024 là năm nhuận nên tháng 2 có 29 ngày)

Input 02:

1 2 2024

Output 02:

32

Nhập vào một mảng các số nguyên A có N phần tử và một số nguyên X, đếm xem có bao nhiêu phần tử trong mảng lớn hơn hoặc bằng X.

(Nếu code bằng Python thì mỗi số sẽ được nhập trên một dòng, cần đọc từng dòng một)

Ràng buộc: ~0 < N \leq 10^6~; ~-10^6 \leq A[i], X \leq 10^6~

Dữ liệu vào gồm 2 dòng, dòng thứ nhất là số lượng N phần tử và X, dòng thứ 2 là N phần tử trong mảng A.

Input 01:

5 3
5 1 4 6 3

Output 01:

4

Input 02:

6 2
1 3 1 4 1 7

Output 02:

3

Nhập vào một mảng các số nguyên A có N phần tử, tìm phần tử là số nguyên tố đầu tiên trong mảng. Nếu có thì in ra vị trí của nó, nếu không có thì in ra NONE

Ràng buộc: ~0 < N \leq 10^6~; ~0 \leq A[i] \leq 10^6~

Dữ liệu vào gồm 2 dòng, dòng thứ nhất là số lượng N, dòng thứ 2 là N phần tử trong mảng A.

In ra vị trí của số nguyên tố đầu tiên trong mảng

Input 01:

5
5 1 4 6 3

Output 01:

1

Số nguyên tố đầu tiên trong mảng ở vị trí 1

Input 02:

6
1 4 1 4 1 8

Output 02:

NONE

Nhập vào một mảng các số nguyên A có N phần tử, tính tổng các số nguyên tố trong mảng.

Ràng buộc: ~0 < N \leq 10^6~; ~0 \leq A[i] \leq 10^6~

Dữ liệu vào gồm 2 dòng, dòng thứ nhất là số lượng N phần tử, dòng thứ 2 lần lượt là N phần tử trong mảng A.

In ra tổng các số nguyên tố trong mảng

Input 01:

5
5 1 4 6 3

Output 01:

8

Trong mảng a có 2 số nguyên tố là 5 và 3, tổng bằng 8

Input 02:

6
1 3 1 4 1 7

Output 02:

10

Nhập vào một mảng các số nguyên A có N phần tử và một số nguyên X, đếm xem X xuất hiện bao nhiêu lần trong mảng.

Ràng buộc: ~0 < N \leq 10^6~; ~-10^6 \leq A[i], X \leq 10^6~

Dữ liệu vào gồm 2 dòng, dòng thứ nhất là số lượng N phần tử và X, dòng thứ 2 lần lượt là N phần tử trong mảng A.

Lưu ý: Nếu code bằng Python thì nhập một giá trị số trên 1 dòng

Input 01:

5 3
5 1 4 6 3

Output 01:

1

Số 3 xuất hiện 1 lần trong mảng

Input 02:

6 2
1 3 1 4 1 7

Output 02:

0

Nhập vào một mảng các số nguyên A có N phần tử, tìm phần tử chẵn, lẻ đầu tiên trong mảng.

Ràng buộc: ~0 < N \leq 10^6~; ~-10^6 \leq A[i] \leq 10^6~

Dữ liệu vào gồm 2 dòng, dòng thứ nhất là số lượng N phần tử, dòng thứ 2 lần lượt là N phần tử trong mảng A.

In phần tử chẵn và lẻ đầu tiên trong mảng kèm theo vị trí của phần tử đó. Nếu số chẵn hoặc số lẻ không xuất hiện thì in ra NONE

Input 01:

5
5 1 4 6 3

Output 01:

4 3
5 1

Số 4 ở vị trí 3 và số 5 ở vị trí 1

Input 02:

6
1 1 7 1 1 3

Output 02:

NONE
1 1

Số chẵn không xuất hiện trong mảng nên in ra NONE

Nhập vào một mảng các số nguyên A có N phần tử, tìm phần tử chẵn cuối cùng trong mảng.

(Nếu code bằng Python thì mỗi số sẽ được nhập trên một dòng, cần đọc từng dòng một)

Ràng buộc: ~0 < N \leq 10^6~; ~-10^6 \leq A[i] \leq 10^6~

Dữ liệu vào gồm 2 dòng, dòng thứ nhất là số lượng N phần tử, dòng thứ 2 lần lượt là N phần tử trong mảng A.

In phần tử chẵn cuối cùng trong mảng kèm theo vị trí của phần tử đó, nếu số chẵn không xuất hiện thì in ra NONE

Input 01:

5
5 1 4 6 3

Output 01:

6 4

Số 6 ở vị trí 4

Input 02:

6
1 3 1 13 1 7

Output 02:

NONE

Số chẵn không xuất hiện, in ra NONE

Nhập vào một mảng các số nguyên A có N phần tử, in ra các phần tử là ước của phần tử đầu tiên trong mảng. Nếu không có thì in ra NONE

Ràng buộc: ~0 < N \leq 10^6~; ~-10^6 \leq A[i] \leq 10^6~

Dữ liệu vào gồm 2 dòng, dòng thứ nhất là số lượng N phần tử, dòng thứ 2 lần lượt là N phần tử trong mảng A.

In ra các phần tử là ước của phần tử đầu tiên trong mảng trên một dòng, nếu không có thì in ra NONE

Input 01:

5
5 1 4 1 3

Output 01:

1 1

Số 1 là ước của phần tử đầu tiên là 5

Input 02:

6
1 3 5 4 6 7

Output 02:

NONE

Số 1 không có ước nào

Nhập vào một mảng các số nguyên A có N phần tử, tìm phần tử chính phương cuối cùng trong mảng. Nếu không có số chính phương nào thì in ra NONE

Ràng buộc: ~0 < N \leq 10^6~; ~0 \leq A[i] \leq 10^6~

Dữ liệu vào gồm 2 dòng, dòng thứ nhất là số lượng N phần tử, dòng thứ 2 lần lượt là N phần tử trong mảng A.

In phần tử chính phương cuối cùng trong mảng kèm theo vị trí của phần tử đó

Input 01:

5
5 1 4 6 16

Output 01:

16 5

Số 16 ở vị trí 5

Input 02:

6
10 3 1 12 1 7

Output 02:

NONE

Nhập vào một mảng các số nguyên A có N phần tử, kiểm tra xem mảng vừa nhập có phải là mảng tăng dần không, nếu đúng in ra YES, ngược lại in ra NO

Ràng buộc: ~0 < N \leq 10^6~; ~-10^6 \leq A[i] \leq 10^6~

Dữ liệu vào gồm 2 dòng, dòng thứ nhất là số lượng N phần tử, dòng thứ 2 lần lượt là N phần tử trong mảng A.

Lưu ý: Nếu code bằng Python thì nhập một giá trị số trên 1 dòng

Input 01:

5
5 1 4 6 3

Output 01:

NO

Input 02:

6
1 1 2 3 4 5

Output 02:

YES

Nhập vào một mảng các số nguyên A có N phần tử, tìm phần tử lớn nhất đầu tiên trong mảng.

Ràng buộc: ~0 < N \leq 10^6~; ~-10^6 \leq A[i] \leq 10^6~

Dữ liệu vào gồm 2 dòng, dòng thứ nhất là số lượng N phần tử, dòng thứ 2 lần lượt là N phần tử trong mảng A.

In phần tử lớn nhất đầu tiên trong mảng kèm theo vị trí của phần tử đó

Input 01:

5
6 1 4 6 3

Output 01:

6 1

Số 6 lớn nhất đầu tiên ở vị trí 4

Input 02:

6
1 3 1 4 1 7

Output 02:

7 6

Nhập vào một mảng các số nguyên A có N phần tử, tìm phần tử nhỏ nhất cuối cùng có trong mảng.

Ràng buộc: ~0 < N \leq 10^6~; ~-10^6 \leq A[i] \leq 10^6~

Dữ liệu vào gồm 2 dòng, dòng thứ nhất là số lượng N phần tử, dòng thứ 2 lần lượt là N phần tử trong mảng A.

In phần tử nhỏ nhất cuối cùng trong mảng kèm theo vị trí của phần tử đó

Input 01:

5
6 1 4 6 1

Output 01:

1 5

Số 1 nhỏ nhất cuối cùng ở vị trí 5

Input 02:

6
1 3 1 4 0 7

Output 02:

0 5

Nhập vào mảng A có N phần tử là các số nguyên, hãy liệt kê các chỉ số i trong mảng thỏa mãn: Tổng các phần tử bên trái i và tổng các phần tử bên phải i là số nguyên tố.

Ràng buộc: ~1 <= N <= 10^3~; ~-10^6 <= A[i] <= 10^6~

Input:

5
53 5 69 47 19

Output:

3

Cho mảng các số nguyên A gồm N phần tử, hãy liệt kê các số là số Fibonacci có trong mảng

Ràng buộc: 1 <= N <= 10^6; 0 <= A[i] <= 10^18

Input:

6
2 3 4 8 9 10

Output:

2 3 8

Cho mảng A có N phần tử là các số nguyên. Hãy tính trung bình cộng các số nguyên tố trong mảng, làm tròn lấy 2 chữ số sau phần thập phân

Ràng buộc: ~1<=N<=1000; 0<=A[i]<=10^3~

Input:

5
1 2 3 4 5

Output:

3.33

Cho mảng A gồm N phần tử là số nguyên, hãy tìm số nhỏ nhất trong mảng và đếm xem có bao nhiêu số là số nhỏ nhất.

Ràng buộc: 1<=N<=1000; -10^3<=A[i]<=10^18

Input:

6
3 1 2 1 4 5

Output:

1 2

Giải thích: Số 1 là số nhỏ nhất và xuất hiện 2 lần

Cho mảng A gồm N phần tử là số nguyên, tìm ước chung lớn nhất của tất cả các phần tử trong mảng (là số lớn nhất mà tất cả các số trong mảng đều chia hết)

Ràng buộc: ~1<=N<=10^6; 0<=A[i]<=10^6~

Input 01:

6
2 4 6 8 10 8

Output 01:

2

Input 02:

7
5 10 15 20 25 30 40

Output 02:

5

Cho mảng số nguyên A gồm N phần tử, hãy tìm độ chênh lệch nhỏ nhất giữa 2 phần tử bất kỳ trong mảng

Đầu vào: Dòng đầu tiên là số nguyên dương N; Dòng thứ 2 gồm N các số nguyên cách nhau một khoảng trắng

Ràng buộc: ~1 <= N <= 1000~; ~0 <= A[i] <= 10^6~

Đầu ra: In ra độ chênh lệch nhỏ nhất giữa 2 phần tử bất kỳ trong mảng

Ví dụ:

Input 01:

5
4 1 6 2 10

Output 01:

1

Input 02

6
-5 1 -2 7 4 -3

Output 02:

1

Cho mảng A[] gồm N số nguyên không âm và số K. Nhiệm vụ của bạn là hãy chia mảng A[] thành hai mảng con có kích cỡ K và N-K sao cho hiệu giữa tổng hai mảng con là lớn nhất.

Ví dụ : mảng A[] = {8, 4, 5, 2, 10}, K=2 ta có kết quả là 17 vì mảng A[] được chia thành hai mảng {4, 2} và { 8, 5,10} có hiệu của hai mảng con là 23-6=17 là lớn nhất.

Gợi ý : Đưa những số nhỏ về tập có ít phần tử, những số lớn về tập có nhiều phần tử thì độ lệch sẽ lớn nhất.

Đầu vào

Dòng đầu tiên là 2 số N và K.

Dòng thứ 2 là N số trong mảng A

Giới hạn

1≤ K < N ≤ 10^5

0 ≤ A[i] ≤ 10^7

Đầu ra

In ra hiệu lớn nhất có thể.

Ví dụ :

Input 01

5 2
8 4 5 2 10

Output 01

17

Cho mảng A[] gồm N phần tử, mảng B gồm M phần tử. Nhiệm vụ của bạn là xác định xem B có phải là một mảng con (không cần liên tiếp nhưng cần giữ đúng thứ tự các phần tử) của mảng A.

Ví dụ mảng A[] = {1, 1, 2, 8, 9, 3, 4}, B[] = {1, 2, 9, 4} là một mảng con của mảng A

Đầu vào

Dòng đầu tiên gồm N và M

Dòng thứ 2 gồm N số A[i]

Dòng thứ 3 gồm M số B[i]

Giới hạn

1<=N,M<=10^6

1<=A[i],B[i]<=10^6

Đầu ra

In ra YES nếu B là mảng con của A, ngược lại in NO.

Ví dụ :

Input 01

16 2
3 6 10 10 10 2 8 4 2 1 9 4 2 1 6 3 
2 3

Output 01

YES

Cho mảng số nguyên A[] gồm N phần tử, kiểm tra xem mảng có đối xứng hay không?

Đầu vào

Dòng đầu tiên là số nguyên dương N

Dòng thứ 2 gồm N số nguyên viết cách nhau một vài khoảng trắng

Giới hạn

1<=N<=10^6

0<=A[i]<=10^6

Đầu ra

In ra YES hoặc NO tương ứng với mảng đối xứng hoặc không.

Ví dụ :

Input 01

5
1 2 3 2 1

Output 01

YES

Input 02

6
1 2 3 2 1 1

Output 02

NO