Cho dãy số A gồm N phần tử đã sắp xếp tăng dần (có thể có phần tử trùng nhau). Hãy tìm vị trí xuất hiện đầu tiên của số X trong dãy. Nếu không tìm thấy, in ra -1. (Các vị trí được đánh số từ 1 đến N).

Dữ liệu vào:

Dòng 1: N và X.

Dòng 2: N số nguyên của dãy A.

Dữ liệu ra:

Vị trí đầu tiên của X hoặc -1.

Ràng buộc:

1 <= N <= 10^5

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

Ví dụ:

Input:

6 3 
1 2 3 3 3 5

Output:

3

Cho mảng A gồm N phần tử. Sử dụng hàm có sẵn tìm vị trí đầu tiên của phần tử lớn hơn hoặc bằng X.

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

Dòng tiếp theo nhập N giá trị của mảng A

In ra vị trí nếu tìm thấy, nếu không tìm thấy thì in ra N.

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

Input 01:

10 6
3 5 6 6 6 6 9 10 11 13

Output 01:

2

Vị trí đầu tiên trong mảng lớn hơn hoặc bằng 6 là vị trí có chỉ số là 2 (có giá trị là 6)

Input 02:

10 14
3 5 6 6 6 6 9 10 11 13

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ử 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ử 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ử, 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ử, 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ử, 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 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

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

Nhập vào mảng một chiều gồm n phần tử, và phần tử x, tìm phần tử trong mảng cách xa x nhất. Dữ liệu đầu vào dòng đầu tiên là số phần tử trong mảng, dòng thứ 2 là các phần tử trong mảng, dòng thứ 3 là giá trị của x.

Ví dụ:

Input:

5
1 2 3 -5 15
3

Output:

15