description
stringlengths 171
4k
| code
stringlengths 94
3.98k
| normalized_code
stringlengths 57
4.99k
|
|---|---|---|
The Rumbling is a hypothetical cataclysmic event involving Karl Fritz's Wall Titans marching across the Earth, destroying all life upon it. Eren Yeager who possesses the Founding Titan has decided to begin The Rumbling to show the true power of the Eldians to the rest of the world.
There are N Titans standing in a line from west to east. Each of the Titans is facing one of the four directions i.e., North, South, East, or West, represented by uppercase English letters 'N', 'S', 'E', and 'W' respectively.
A Titan can rotate on the spot where it is standing. It requires X units of energy to rotate 90 degrees clockwise, and Y units of energy to rotate 90 degrees anti-clockwise.
For the activation of The Rumbling, all the Titans must face Eren Yeager.
So, Eren wants to position himself on the West-East line (on which other Titans are standing). He can either stand to the left of all Titans, in between two consecutive Titans, or to the right of all Titans. He wants to choose a position that minimizes the units of energy required by all the Titans to rotate and face him. Find the minimum units of energy required by all the Titans for the Activation of the Rumbling in the optimal configuration.
------ Input Format ------
- The first line consists of T, the number of test cases. Description of the test cases follow.
- The first line of each test case will contain N, the number of Titans.
- The second line of each test case will contain a string S of length N, where the i^{th} character represents the directions faced by the i^{th} Titan.
- The third line of each test case will contain two space-separated integers, the values of X and Y.
------ Output Format ------
For each test case, output a single line containing one integer, the answer to that test case.
------ Constraints ------
$1 ≤ T ≤ 1000$
$1 ≤ N ≤ 2 * 10^{5}$
$1 ≤ X, Y ≤ 10^{9}$
$S$ contains characters from {'N', 'S', 'E', 'W'} only.
- Sum of $N$ over all test cases doesn't exceed $10^{6}$
----- Sample Input 1 ------
1
5
SENWS
2 1
----- Sample Output 1 ------
4
----- explanation 1 ------
- One valid configuration would be as follows: $EE \cdot WWW$, where $\cdot$ represents the position of Eren Yeager.
- The first and the second Titans will face Eren at East from the left while the third, fourth, and the fifth Titans will face Eren at West from the right.
- It takes $1$ unit of energy for the first Titan to move towards East by rotating $90$ degrees anticlockwise.
- The second Titan is already facing East, so it costs him $0$ units of energy to stay that way.
- It takes $1$ unit of energy for the third Titan to move towards West by rotating $90$ degrees anticlockwise.
- The fourth Titan is already facing West, so it costs him $0$ units of energy to stay that way.
- It takes $2$ units of energy for the fifth Titan to move towards West by rotating $90$ degrees clockwise.
- So, it takes the Titans $4$ units of energy overall to face Eren Yeager, and activate The Rumbling!
|
for _ in range(int(input())):
n = int(input())
s = input()
x, y = map(int, input().split())
ei = [0]
wi = [0]
e = w = 0
for i in range(n):
if s[i] == "S":
e = e + min(3 * x, y)
elif s[i] == "N":
e = e + min(x, 3 * y)
elif s[i] == "W":
e = e + min(2 * x, 2 * y)
ei.append(e)
if s[n - 1 - i] == "S":
w = w + min(x, 3 * y)
elif s[n - 1 - i] == "N":
w = w + min(3 * x, y)
elif s[n - 1 - i] == "E":
w = w + min(2 * x, 2 * y)
wi.append(w)
ans = w
for i in range(n + 1):
ans = min(ans, ei[i] + wi[n - i])
print(ans)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST NUMBER ASSIGN VAR LIST NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR STRING ASSIGN VAR BIN_OP VAR FUNC_CALL VAR BIN_OP NUMBER VAR VAR IF VAR VAR STRING ASSIGN VAR BIN_OP VAR FUNC_CALL VAR VAR BIN_OP NUMBER VAR IF VAR VAR STRING ASSIGN VAR BIN_OP VAR FUNC_CALL VAR BIN_OP NUMBER VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR VAR IF VAR BIN_OP BIN_OP VAR NUMBER VAR STRING ASSIGN VAR BIN_OP VAR FUNC_CALL VAR VAR BIN_OP NUMBER VAR IF VAR BIN_OP BIN_OP VAR NUMBER VAR STRING ASSIGN VAR BIN_OP VAR FUNC_CALL VAR BIN_OP NUMBER VAR VAR IF VAR BIN_OP BIN_OP VAR NUMBER VAR STRING ASSIGN VAR BIN_OP VAR FUNC_CALL VAR BIN_OP NUMBER VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR
|
The Rumbling is a hypothetical cataclysmic event involving Karl Fritz's Wall Titans marching across the Earth, destroying all life upon it. Eren Yeager who possesses the Founding Titan has decided to begin The Rumbling to show the true power of the Eldians to the rest of the world.
There are N Titans standing in a line from west to east. Each of the Titans is facing one of the four directions i.e., North, South, East, or West, represented by uppercase English letters 'N', 'S', 'E', and 'W' respectively.
A Titan can rotate on the spot where it is standing. It requires X units of energy to rotate 90 degrees clockwise, and Y units of energy to rotate 90 degrees anti-clockwise.
For the activation of The Rumbling, all the Titans must face Eren Yeager.
So, Eren wants to position himself on the West-East line (on which other Titans are standing). He can either stand to the left of all Titans, in between two consecutive Titans, or to the right of all Titans. He wants to choose a position that minimizes the units of energy required by all the Titans to rotate and face him. Find the minimum units of energy required by all the Titans for the Activation of the Rumbling in the optimal configuration.
------ Input Format ------
- The first line consists of T, the number of test cases. Description of the test cases follow.
- The first line of each test case will contain N, the number of Titans.
- The second line of each test case will contain a string S of length N, where the i^{th} character represents the directions faced by the i^{th} Titan.
- The third line of each test case will contain two space-separated integers, the values of X and Y.
------ Output Format ------
For each test case, output a single line containing one integer, the answer to that test case.
------ Constraints ------
$1 ≤ T ≤ 1000$
$1 ≤ N ≤ 2 * 10^{5}$
$1 ≤ X, Y ≤ 10^{9}$
$S$ contains characters from {'N', 'S', 'E', 'W'} only.
- Sum of $N$ over all test cases doesn't exceed $10^{6}$
----- Sample Input 1 ------
1
5
SENWS
2 1
----- Sample Output 1 ------
4
----- explanation 1 ------
- One valid configuration would be as follows: $EE \cdot WWW$, where $\cdot$ represents the position of Eren Yeager.
- The first and the second Titans will face Eren at East from the left while the third, fourth, and the fifth Titans will face Eren at West from the right.
- It takes $1$ unit of energy for the first Titan to move towards East by rotating $90$ degrees anticlockwise.
- The second Titan is already facing East, so it costs him $0$ units of energy to stay that way.
- It takes $1$ unit of energy for the third Titan to move towards West by rotating $90$ degrees anticlockwise.
- The fourth Titan is already facing West, so it costs him $0$ units of energy to stay that way.
- It takes $2$ units of energy for the fifth Titan to move towards West by rotating $90$ degrees clockwise.
- So, it takes the Titans $4$ units of energy overall to face Eren Yeager, and activate The Rumbling!
|
def cost(val, x, y, desired):
if val == "N":
if desired == "W":
return min(y, x * 3)
else:
return min(x, y * 3)
elif val == "S":
if desired == "W":
return min(x, y * 3)
else:
return min(y, x * 3)
elif val == "E":
if desired == "W":
return 2 * min(x, y)
else:
return 0
elif desired == "W":
return 0
else:
return 2 * min(x, y)
t = int(input())
for xyz in range(t):
n = int(input())
s = input()
x, y = list(map(int, input().split()))
alle = 0
allw = 0
for i in s:
alle += cost(i, x, y, "E")
allw += cost(i, x, y, "W")
mincost = min(alle, allw)
allee = alle
for i in range(n - 1, 0, -1):
allee = allee - cost(s[i], x, y, "E") + cost(s[i], x, y, "W")
mincost = min(mincost, allee)
allww = allw
for i in range(0, n - 1):
allww = allww - cost(s[i], x, y, "W") + cost(s[i], x, y, "E")
mincost = min(mincost, allww)
print(mincost)
|
FUNC_DEF IF VAR STRING IF VAR STRING RETURN FUNC_CALL VAR VAR BIN_OP VAR NUMBER RETURN FUNC_CALL VAR VAR BIN_OP VAR NUMBER IF VAR STRING IF VAR STRING RETURN FUNC_CALL VAR VAR BIN_OP VAR NUMBER RETURN FUNC_CALL VAR VAR BIN_OP VAR NUMBER IF VAR STRING IF VAR STRING RETURN BIN_OP NUMBER FUNC_CALL VAR VAR VAR RETURN NUMBER IF VAR STRING RETURN NUMBER RETURN BIN_OP NUMBER FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR STRING VAR FUNC_CALL VAR VAR VAR VAR STRING ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR FUNC_CALL VAR VAR VAR VAR VAR STRING FUNC_CALL VAR VAR VAR VAR VAR STRING ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR FUNC_CALL VAR VAR VAR VAR VAR STRING FUNC_CALL VAR VAR VAR VAR VAR STRING ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
The Rumbling is a hypothetical cataclysmic event involving Karl Fritz's Wall Titans marching across the Earth, destroying all life upon it. Eren Yeager who possesses the Founding Titan has decided to begin The Rumbling to show the true power of the Eldians to the rest of the world.
There are N Titans standing in a line from west to east. Each of the Titans is facing one of the four directions i.e., North, South, East, or West, represented by uppercase English letters 'N', 'S', 'E', and 'W' respectively.
A Titan can rotate on the spot where it is standing. It requires X units of energy to rotate 90 degrees clockwise, and Y units of energy to rotate 90 degrees anti-clockwise.
For the activation of The Rumbling, all the Titans must face Eren Yeager.
So, Eren wants to position himself on the West-East line (on which other Titans are standing). He can either stand to the left of all Titans, in between two consecutive Titans, or to the right of all Titans. He wants to choose a position that minimizes the units of energy required by all the Titans to rotate and face him. Find the minimum units of energy required by all the Titans for the Activation of the Rumbling in the optimal configuration.
------ Input Format ------
- The first line consists of T, the number of test cases. Description of the test cases follow.
- The first line of each test case will contain N, the number of Titans.
- The second line of each test case will contain a string S of length N, where the i^{th} character represents the directions faced by the i^{th} Titan.
- The third line of each test case will contain two space-separated integers, the values of X and Y.
------ Output Format ------
For each test case, output a single line containing one integer, the answer to that test case.
------ Constraints ------
$1 ≤ T ≤ 1000$
$1 ≤ N ≤ 2 * 10^{5}$
$1 ≤ X, Y ≤ 10^{9}$
$S$ contains characters from {'N', 'S', 'E', 'W'} only.
- Sum of $N$ over all test cases doesn't exceed $10^{6}$
----- Sample Input 1 ------
1
5
SENWS
2 1
----- Sample Output 1 ------
4
----- explanation 1 ------
- One valid configuration would be as follows: $EE \cdot WWW$, where $\cdot$ represents the position of Eren Yeager.
- The first and the second Titans will face Eren at East from the left while the third, fourth, and the fifth Titans will face Eren at West from the right.
- It takes $1$ unit of energy for the first Titan to move towards East by rotating $90$ degrees anticlockwise.
- The second Titan is already facing East, so it costs him $0$ units of energy to stay that way.
- It takes $1$ unit of energy for the third Titan to move towards West by rotating $90$ degrees anticlockwise.
- The fourth Titan is already facing West, so it costs him $0$ units of energy to stay that way.
- It takes $2$ units of energy for the fifth Titan to move towards West by rotating $90$ degrees clockwise.
- So, it takes the Titans $4$ units of energy overall to face Eren Yeager, and activate The Rumbling!
|
def helperRight(i, x, y):
if i == "N":
return min(x, 3 * y)
elif i == "W":
return min(2 * x, 2 * y)
elif i == "S":
return min(3 * x, y)
else:
return 0
def helperLeft(i, x, y):
if i == "N":
return min(3 * x, y)
elif i == "W":
return 0
elif i == "S":
return min(x, 3 * y)
else:
return min(2 * x, 2 * y)
for _ in range(int(input())):
n = int(input())
s = input()
x, y = list(map(int, input().split()))
left = [0] * n
right = [0] * n
right[0] = helperRight(s[0], x, y)
left[n - 1] = helperLeft(s[n - 1], x, y)
for i in range(1, n):
right[i] = helperRight(s[i], x, y) + right[i - 1]
left[n - i - 1] = helperLeft(s[n - i - 1], x, y) + left[n - i]
ans = left[0]
for i in range(n - 1):
ans = min(ans, right[i] + left[i + 1])
ans = min(ans, right[n - 1])
print(ans)
|
FUNC_DEF IF VAR STRING RETURN FUNC_CALL VAR VAR BIN_OP NUMBER VAR IF VAR STRING RETURN FUNC_CALL VAR BIN_OP NUMBER VAR BIN_OP NUMBER VAR IF VAR STRING RETURN FUNC_CALL VAR BIN_OP NUMBER VAR VAR RETURN NUMBER FUNC_DEF IF VAR STRING RETURN FUNC_CALL VAR BIN_OP NUMBER VAR VAR IF VAR STRING RETURN NUMBER IF VAR STRING RETURN FUNC_CALL VAR VAR BIN_OP NUMBER VAR RETURN FUNC_CALL VAR BIN_OP NUMBER VAR BIN_OP NUMBER VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR VAR ASSIGN VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR BIN_OP FUNC_CALL VAR VAR VAR VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER BIN_OP FUNC_CALL VAR VAR BIN_OP BIN_OP VAR VAR NUMBER VAR VAR VAR BIN_OP VAR VAR ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR
|
The Rumbling is a hypothetical cataclysmic event involving Karl Fritz's Wall Titans marching across the Earth, destroying all life upon it. Eren Yeager who possesses the Founding Titan has decided to begin The Rumbling to show the true power of the Eldians to the rest of the world.
There are N Titans standing in a line from west to east. Each of the Titans is facing one of the four directions i.e., North, South, East, or West, represented by uppercase English letters 'N', 'S', 'E', and 'W' respectively.
A Titan can rotate on the spot where it is standing. It requires X units of energy to rotate 90 degrees clockwise, and Y units of energy to rotate 90 degrees anti-clockwise.
For the activation of The Rumbling, all the Titans must face Eren Yeager.
So, Eren wants to position himself on the West-East line (on which other Titans are standing). He can either stand to the left of all Titans, in between two consecutive Titans, or to the right of all Titans. He wants to choose a position that minimizes the units of energy required by all the Titans to rotate and face him. Find the minimum units of energy required by all the Titans for the Activation of the Rumbling in the optimal configuration.
------ Input Format ------
- The first line consists of T, the number of test cases. Description of the test cases follow.
- The first line of each test case will contain N, the number of Titans.
- The second line of each test case will contain a string S of length N, where the i^{th} character represents the directions faced by the i^{th} Titan.
- The third line of each test case will contain two space-separated integers, the values of X and Y.
------ Output Format ------
For each test case, output a single line containing one integer, the answer to that test case.
------ Constraints ------
$1 ≤ T ≤ 1000$
$1 ≤ N ≤ 2 * 10^{5}$
$1 ≤ X, Y ≤ 10^{9}$
$S$ contains characters from {'N', 'S', 'E', 'W'} only.
- Sum of $N$ over all test cases doesn't exceed $10^{6}$
----- Sample Input 1 ------
1
5
SENWS
2 1
----- Sample Output 1 ------
4
----- explanation 1 ------
- One valid configuration would be as follows: $EE \cdot WWW$, where $\cdot$ represents the position of Eren Yeager.
- The first and the second Titans will face Eren at East from the left while the third, fourth, and the fifth Titans will face Eren at West from the right.
- It takes $1$ unit of energy for the first Titan to move towards East by rotating $90$ degrees anticlockwise.
- The second Titan is already facing East, so it costs him $0$ units of energy to stay that way.
- It takes $1$ unit of energy for the third Titan to move towards West by rotating $90$ degrees anticlockwise.
- The fourth Titan is already facing West, so it costs him $0$ units of energy to stay that way.
- It takes $2$ units of energy for the fifth Titan to move towards West by rotating $90$ degrees clockwise.
- So, it takes the Titans $4$ units of energy overall to face Eren Yeager, and activate The Rumbling!
|
def get_min(n, s, x, y):
l = []
r = []
for i in s:
if i == "N":
l.append(min(y, 3 * x))
r.append(min(x, 3 * y))
elif i == "S":
l.append(min(x, 3 * y))
r.append(min(y, 3 * x))
elif i == "E":
l.append(min(2 * x, 2 * y))
r.append(0)
else:
l.append(0)
r.append(min(2 * x, 2 * y))
lp = [0]
rp = [0]
ls = 0
rs = 0
for i in l[::-1]:
ls += i
lp.append(ls)
for i in r:
rs += i
rp.append(rs)
lp = lp[::-1]
ans = float("inf")
for i in range(len(lp)):
ans = min(ans, lp[i] + rp[i])
print(ans)
for i in range(int(input())):
n = int(input())
s = input()
x, y = map(int, input().split())
get_min(n, s, x, y)
|
FUNC_DEF ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR VAR IF VAR STRING EXPR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP NUMBER VAR IF VAR STRING EXPR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP NUMBER VAR IF VAR STRING EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP NUMBER VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP NUMBER VAR BIN_OP NUMBER VAR ASSIGN VAR LIST NUMBER ASSIGN VAR LIST NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR NUMBER VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR STRING FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
def ot(n, a):
i = 0
j = n - 1
while i <= j:
if a[i] == 1:
break
if a[j] == 1:
break
i += 1
j -= 1
if i > j:
return n
total_s = sum(a) - 2 * i
return total_s + i
def m():
ans = []
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
ans.append(ot(n, a))
for x in ans:
print(x)
m()
|
FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER WHILE VAR VAR IF VAR VAR NUMBER IF VAR VAR NUMBER VAR NUMBER VAR NUMBER IF VAR VAR RETURN VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR BIN_OP NUMBER VAR RETURN BIN_OP VAR VAR FUNC_DEF ASSIGN VAR LIST FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
T = int(input())
for _ in range(T):
N = int(input())
A = [int(x) for x in input().split()]
if len(set(A)) == 1:
print(N)
else:
s = sum(A)
if A[0] == A[-1] == 2:
print(s - 1)
else:
print(s)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR IF FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
T = int(input())
for t in range(T):
N = int(input())
A = [int(i) for i in input().split()]
Sum = sum(A)
if Sum == N or Sum == 2 * N:
print(N)
else:
ind = 0
while A[ind] == A[N - 1 - ind] == 2:
ind += 1
print(Sum - ind)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER WHILE VAR VAR VAR BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
while t > 0:
n = int(input())
a = list(map(int, input().split()))
summ = a[0]
if summ == 1:
flag = 1
else:
flag = 0
add = 1
if flag == 1:
for i in range(1, n):
summ += a[i]
add = summ
else:
for i in range(1, n):
if a[i] == 1:
summ += a[i]
add = summ
else:
summ += a[i]
add += 1
print(add)
t -= 1
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR VAR VAR VAR ASSIGN VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR NUMBER VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR NUMBER
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
test = int(input())
for _ in range(test):
nof = int(input())
seq = list(map(int, input().split()))
s = []
for i in seq:
if i not in s:
s.append(i)
sum1 = 0
if len(s) == 1:
print(len(seq))
else:
ind = 0
while seq[ind] == seq[nof - 1 - ind] == 2:
ind += 1
print(sum(seq) - ind)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER IF FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER WHILE VAR VAR VAR BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
for _ in range(int(input())):
N = int(input())
array = list(map(int, input().split()))
p = sum(array)
oneCount = array.count(1)
if oneCount == 0:
print(p // 2)
elif oneCount == 1:
k = array.index(1)
forward = sum(array[:k])
backward = p - forward - 1
p -= max(forward, backward) // 2
print(p)
else:
print(p)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER VAR BIN_OP FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
x = int(input())
for i in range(x):
z = int(input())
l = list(map(int, input().split()))
s = sum(l)
if l.count(2) != 0:
if l[0] == 2 and l[-1] == 2 and l.count(2) != z:
print(s - 1)
elif l.count(2) == z:
print(s // 2)
else:
print(s)
else:
print(s)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR NUMBER NUMBER IF VAR NUMBER NUMBER VAR NUMBER NUMBER FUNC_CALL VAR NUMBER VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER IF FUNC_CALL VAR NUMBER VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
def find_front_one(arr, n):
count = 0
for i in range(n):
if arr[i] == 1:
break
count += 1
return count
def find_back_one(arr, n):
count = 0
for i in range(n - 1, -1, -1):
if arr[i] == 1:
break
count += 1
return count
t = int(input())
for i in range(t):
n = int(input())
SUM = 0
arr = list(map(int, input().split()))
SUM = sum(arr)
f1 = find_front_one(arr, n)
f2 = find_back_one(arr, n)
print(SUM - min(f1, f2))
|
FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR NUMBER VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR FUNC_CALL VAR VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
b = set(a)
if len(b) == 1:
print(n)
elif a[0] == a[-1] == 2:
print(sum(a) - 1)
else:
print(sum(a))
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR IF VAR NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
T = int(input())
while T > 0:
n = int(input())
a = list(map(int, input().split()))
c1 = 0
c2 = 0
s = sum(a)
for i in range(n):
if a[i] == 2:
c1 += 1
else:
break
for i in range(n - 1, -1, -1):
if a[i] == 2:
c2 += 1
else:
break
s1 = sum(a[c1:])
s2 = sum(a[: n - c2])
if c1 == n:
print(c1)
else:
print(int(max(s1, s2) + (s - max(s1, s2)) / 2))
T -= 1
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR BIN_OP BIN_OP VAR FUNC_CALL VAR VAR VAR NUMBER VAR NUMBER
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
for i in range(int(input())):
N = int(input())
l = list(map(int, input().split()))
s = sum(l)
ans = 0
count_of_1 = l.count(1)
if s % 2 == 0:
ans = N if count_of_1 == 0 else s
else:
ind = l.index(1)
ans = s if count_of_1 > 1 else s - min(ind, N - 1 - ind)
print(ans)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR NUMBER VAR BIN_OP VAR FUNC_CALL VAR VAR BIN_OP BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
for t in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
x = sum(a)
if x == 2 * n:
print(n)
elif a == [2, 1, 2]:
print("4")
else:
print(x)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR VAR IF VAR LIST NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
def m():
t = int(input())
while t > 0:
count = 0
n = int(input())
k = 2 * n
l1 = [(0) for i in range(k + 1)]
l2 = list(map(int, input().split()))
sum1 = sum(l2)
if k == sum1:
print(n)
elif l2 == [2, 1, 2]:
print(4)
else:
print(sum1)
t = t - 1
m()
|
FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP NUMBER VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR IF VAR LIST NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
while t > 0:
onec = 0
summ = 0
li = []
n = int(input())
li = list(map(int, input().split()))
for i in range(0, n):
k = li[i]
if k == 1:
onec += 1
summ += k
if onec != 0:
if li[0] == 2 and li[n - 1] == 2:
print(summ - 1)
else:
print(summ)
else:
print(int(summ / 2))
t -= 1
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR LIST ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR VAR IF VAR NUMBER VAR NUMBER VAR VAR IF VAR NUMBER IF VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
for i in range(t):
n = int(input())
l = list(map(int, input().split()))
p = sum(l)
m1 = 2 * n
m2 = n
if p == m1 or p == m2:
print(n)
elif l[0] == l[-1] == 2:
print(p - 1)
else:
print(p)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP NUMBER VAR ASSIGN VAR VAR IF VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR IF VAR NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
def solve():
n = int(input())
a = list(map(int, input().split()))
x = sum(a)
if not a.__contains__(1):
print(n)
return
elif a[0] == 2 and a[n - 1] == 2:
print(x - 1)
return
else:
print(x)
return
try:
t = int(input())
for i in range(t):
solve()
except:
pass
|
FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN IF VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER RETURN EXPR FUNC_CALL VAR VAR RETURN ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
for i in range(t):
n = int(input())
l = list(map(int, input().split()))
if l[-1] == l[0] == 2:
if sum(l) != 2 * n:
print(sum(l) - 1)
else:
print(n)
else:
print(sum(l))
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR NUMBER VAR NUMBER NUMBER IF FUNC_CALL VAR VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
for _ in range(int(input())):
n = int(input())
ar = list(map(int, input().split()))
s = sum(ar)
if 1 in ar:
cnt = 0
for i in range(n):
if ar[i] != 2 or ar[n - 1 - i] != 2:
break
else:
cnt += 1
print(s - cnt)
else:
print(int(s / 2))
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR IF NUMBER VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER VAR BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
T = int(input())
ans = []
for _ in range(T):
N = int(input())
A = [int(i) for i in input().split()]
first = None
last = None
for i in range(N):
if A[i] == 1 and first == None:
first = i
if A[i] == 1:
last = i
if first != None:
x = min(first, N - last - 1)
ans.append(sum(A) - x)
else:
ans.append(sum(A) // 2)
for i in ans:
print(i)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NONE ASSIGN VAR NONE FOR VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER VAR NONE ASSIGN VAR VAR IF VAR VAR NUMBER ASSIGN VAR VAR IF VAR NONE ASSIGN VAR FUNC_CALL VAR VAR BIN_OP BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER FOR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
for ijk in range(0, t):
n = int(input())
a = list(map(int, input().strip().split()))
su = sum(a)
c = a.count(1)
if su % 2 == 0 and c == 0:
print(n)
elif su % 2 == 0 and c != 0:
print(su)
elif su % 2 == 1 and c == 1:
ind = a.index(1)
you = min(ind, n - 1 - ind)
print(su - you)
else:
print(su)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
for i in range(t):
n = int(input())
arr = [int(x) for x in input().split()]
sum = 0
for j in range(len(arr)):
sum = sum + arr[j]
flag = 0
for j in range(len(arr)):
if arr[j] == 1:
flag = 1
if flag == 1:
if arr[0] == 2 and arr[len(arr) - 1] == 2:
print(sum - 1)
else:
print(sum)
else:
print(sum // 2)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER IF VAR NUMBER NUMBER VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
try:
n = min(a.index(1), next(i for i, x in enumerate(reversed(a)) if x == 1))
except ValueError:
pass
print(sum(a) - n)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR NUMBER VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
def f():
t = int(input())
while t > 0:
n = int(input())
sum1 = 0
k = []
sum1 = 0
l = list(map(int, input().split()))
for i in range(len(l)):
sum1 = sum1 + l[i]
k.append(sum1)
z = sum1
for i in range(len(k) - 1, -1, -1):
if k[i] % 2 == 0:
g2 = k[i]
break
else:
g2 = 0
for i in range(len(k) - 1, -1, -1):
if k[i] % 2 != 0:
g3 = k[i]
break
else:
g3 = 0
for i in range(len(l)):
z = z - l[i]
if z % 2 == 0:
g4 = z
break
else:
g4 = 0
z = sum1
for i in range(len(l)):
z = z - l[i]
if z % 2 != 0:
g5 = z
break
else:
g5 = 0
if g2 > g4:
g1 = g2
else:
g1 = g4
if g3 > g5:
g = g3
else:
g = g5
e = 1 + (g - 1) / 2
e1 = 1 + (g1 - 2) / 2
print(int(e + e1))
t = t - 1
f()
|
FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR LIST ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER NUMBER IF BIN_OP VAR VAR NUMBER NUMBER ASSIGN VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER NUMBER IF BIN_OP VAR VAR NUMBER NUMBER ASSIGN VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR ASSIGN VAR NUMBER ASSIGN VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR ASSIGN VAR NUMBER IF VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR IF VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR BIN_OP NUMBER BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP NUMBER BIN_OP BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
result = []
for i in range(t):
n = int(input())
arr = input().split()
dup = []
A = [int(arr[j]) for j in range(n)]
if sum(A) % 2 != 0:
if A[0] == 2 and A[-1] == 2:
result.append(sum(A) - 1)
else:
result.append(sum(A))
elif 1 in A:
result.append(sum(A))
else:
result.append(int(sum(A) / 2))
for i in range(len(result)):
print(result[i])
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR IF BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER IF VAR NUMBER NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR IF NUMBER VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
def sub_sums(arr):
sums = [arr[0]]
for i in range(1, len(arr)):
sums.append(sums[-1] + arr[i])
sums.append(arr[1])
for i in range(2, len(arr)):
sums.append(sums[-1] + arr[i])
sums.append(arr[2])
for i in range(3, len(arr)):
sums.append(sums[-1] + arr[i])
if arr[0] != 1 and 1 in arr:
sums.append(1)
return set(sums)
def main():
for _ in range(int(input())):
N = int(input())
arr = [int(k) for k in input().split()]
print(len(sub_sums(arr)))
main()
|
FUNC_DEF ASSIGN VAR LIST VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR EXPR FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR EXPR FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR IF VAR NUMBER NUMBER NUMBER VAR EXPR FUNC_CALL VAR NUMBER RETURN FUNC_CALL VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
for _ in range(t):
n = int(input())
l = list(map(int, input().split()))
s = sum(l)
if l[0] != 2 or l[n - 1] != 2:
print(s)
else:
c = l.count(1)
if c > 0:
first = l.index(1)
l.reverse()
last = l.index(1)
r = min(first, last)
print(s - r)
else:
print(n)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR NUMBER IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
for t0 in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
s = 0
one, two, f, l = 0, 0, -1, -1
for i in range(n):
s += a[i]
if one == 0 and a[i] == 1:
one = 1
if two == 0 and a[i] == 2:
two = 1
if l == -1 and a[i] == 1:
l = i
if a[i] == 1:
r = i
if one == 0:
print(s // 2)
elif two == 0:
print(s)
else:
print(s - min(l, n - 1 - r))
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR VAR VAR VAR NUMBER NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR VAR VAR VAR IF VAR NUMBER VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER VAR VAR NUMBER ASSIGN VAR VAR IF VAR VAR NUMBER ASSIGN VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR FUNC_CALL VAR VAR BIN_OP BIN_OP VAR NUMBER VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
for _ in range(int(input())):
n = int(input())
l = [int(i) for i in input().split()]
s = sum(l)
i = 0
while i < n and l[i] == 2:
i += 1
j = 0
while j < n and l[n - 1 - j] == 2:
j += 1
print(s - min(i, j))
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER WHILE VAR VAR VAR VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER WHILE VAR VAR VAR BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR FUNC_CALL VAR VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
for _ in range(t):
n = int(input())
arr = [int(x) for x in input().split()]
c1 = 0
c2 = 0
for i in range(n):
if arr[i] != 2:
break
c1 += 1
for i in range(n - 1, -1, -1):
if arr[i] != 2:
break
c2 += 1
print(sum(arr) - min(c1, c2))
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
for tes in range(t):
n = int(input())
arr = list(map(int, input().split()))
c1 = 0
c2 = 0
s = 0
e = 0
o = 0
for i in range(n):
if arr[i] == 1:
c1 += 1
else:
c2 += 1
s += arr[i]
if s % 2 == 0:
e = s
else:
o = s
xx = s
yy = s
if s % 2 == 0:
for i in range(n):
xx -= arr[i]
if xx % 2 == 1:
o = max(o, xx)
else:
e = max(e, xx)
else:
for i in range(n):
yy -= arr[i]
if yy % 2 == 0:
e = max(e, yy)
else:
o = max(o, yy)
print((o + 1) // 2 + e // 2)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR VAR VAR IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR IF BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR VAR VAR VAR IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR VAR VAR VAR VAR IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
while t > 0:
n = int(input())
a = list(map(int, input().split()))
b = set()
flag = 0
count = 0
for i in range(n):
if a[i] == 2 and a[n - i - 1] == 2:
count += 1
flag = 1
else:
break
if flag == 1:
print(sum(a) - count)
else:
print(sum(a))
t -= 1
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR NUMBER
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
while t > 0:
n = int(input())
a = list(map(int, input().split()))
cn = a.count(1)
if cn != 0:
if a[0] == 2 and a[n - 1] == 2:
print(sum(a) - 1)
else:
print(sum(a))
else:
print(sum(a) // 2)
t -= 1
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR NUMBER IF VAR NUMBER IF VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR NUMBER
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
c = 0
s = 0
for i in range(0, t):
n = int(input())
a = [int(x) for x in input().split()]
for j in a:
s += j
if j == 1:
c += 1
if len(a) == c:
print(c)
elif a[0] == 2 and a[n - 1] == 2 and c > 0:
print(s - 1)
elif c == 0:
print(int(s / 2))
else:
print(s)
c = 0
s = 0
a.clear()
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR VAR VAR VAR IF VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR IF VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER EXPR FUNC_CALL VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
if 1 not in arr:
print(n)
elif arr[-1] == 1 or arr[0] == 1:
print(sum(arr))
else:
print(sum(arr) - 1)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF NUMBER VAR EXPR FUNC_CALL VAR VAR IF VAR NUMBER NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
check = [(0) for x in range(2 * n + 1)]
s = 0
tot = sum(a)
i = 0
while i < n and a[i] != 1:
s += a[i]
i += 1
if i == n or a[i] == 2:
for j in range(2, tot + 1, 2):
check[j] = 1
else:
check[1] = 1
for j in range(1, s + 2):
check[j] = 1
for j in range(1, tot - s + 1):
check[j] = 1
i = n - 1
s = 0
while i >= 0 and a[i] != 1:
s += a[i]
i -= 1
if i == -1 or a[i] == 2:
for j in range(2, tot + 1, 2):
check[j] = 1
else:
for j in range(1, s + 2):
check[j] = 1
for j in range(1, tot - s + 1):
check[j] = 1
for j in range(tot, 0, -2):
check[j] = 1
if j > 0 and check[j - 1] == 1:
break
count = 0
for i in range(1, tot + 1):
if check[i]:
count += 1
print(count)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER WHILE VAR VAR VAR VAR NUMBER VAR VAR VAR VAR NUMBER IF VAR VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER WHILE VAR NUMBER VAR VAR NUMBER VAR VAR VAR VAR NUMBER IF VAR NUMBER VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER IF VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
T = int(input())
while T != 0:
N = int(input())
A = list(map(int, input().split()))
s = sum(A)
if s == N or s == 2 * N:
print(N)
elif A[0] == 1 or A[N - 1] == 1:
print(s)
else:
print(s - 1)
T -= 1
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR VAR IF VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().strip().split()))
sum1 = [0] * len(a)
first_index = -1
last_index = -1
sum1[0] = a[0]
for i in range(1, len(a)):
sum1[i] = sum1[i - 1] + a[i]
for i in range(len(a)):
if first_index == -1 and a[i] == 1:
first_index = i
last_index = i
elif a[i] == 1:
last_index = i
vv = len(a) - last_index - 1
if a[0] == 1 or a[len(a) - 1] == 1:
print(sum(a))
elif first_index == -1:
print(n)
elif first_index == last_index:
if sum1[last_index] > sum1[len(a) - 1] - sum1[last_index] + a[last_index]:
an = sum1[last_index] + vv
print(sum1[last_index] + vv)
else:
print(sum1[len(a) - 1] - sum1[last_index] + a[last_index] + last_index)
elif sum1[last_index] > sum1[len(a) - 1] - sum1[first_index - 1]:
print(sum1[last_index] + vv)
else:
print(sum1[len(a) - 1] - sum1[first_index - 1] + first_index)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR NUMBER VAR VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR IF VAR VAR NUMBER ASSIGN VAR VAR ASSIGN VAR BIN_OP BIN_OP FUNC_CALL VAR VAR VAR NUMBER IF VAR NUMBER NUMBER VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR BIN_OP BIN_OP VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR VAR VAR VAR VAR IF VAR VAR BIN_OP VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR BIN_OP VAR NUMBER VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
for _ in range(int(input())):
n = int(input())
arr = [int(i) for i in input().split(" ")]
s = sum(arr)
if s == n or s == 2 * n:
print(n)
continue
red = 0
for a, b in zip(arr, reversed(arr)):
if a + b < 4:
break
red += 1
print(s - red)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF BIN_OP VAR VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
for _ in range(int(input())):
n = int(input())
a = input().split()
b = "".join(a)
a = map(int, a)
x = b.find("1")
y = b[::-1].find("1")
if x == -1:
x = n
if y == -1:
y = n
print(sum(a) - min(x, y))
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL STRING VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR NUMBER STRING IF VAR NUMBER ASSIGN VAR VAR IF VAR NUMBER ASSIGN VAR VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
k = sum(arr)
if k == 2 * n:
print(n)
else:
s = k
for i in range(n // 2):
if arr[i] == 1:
k -= 2 * i
break
elif arr[-(i + 1)] == 1:
k -= 2 * i
break
else:
k = 1 + k // 2
print(k + (s - k) // 2)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR NUMBER VAR BIN_OP NUMBER VAR IF VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP NUMBER VAR ASSIGN VAR BIN_OP NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR BIN_OP BIN_OP VAR VAR NUMBER
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
from sys import stdin
input = stdin.readline
def answer():
s, one = 0, False
for i in range(n):
s += a[i]
if a[i] == 1:
one = True
if one == True:
if a[0] == 2 and a[-1] == 2:
return s - 1
else:
return s
else:
return s // 2
for T in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
print(answer())
|
ASSIGN VAR VAR FUNC_DEF ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR VAR VAR VAR IF VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER IF VAR NUMBER NUMBER VAR NUMBER NUMBER RETURN BIN_OP VAR NUMBER RETURN VAR RETURN BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
import sys
tc = int(sys.stdin.readline())
for i in range(tc):
_ = sys.stdin.readline()
arr = sys.stdin.readline().split()
n = len(arr)
if "1" not in arr:
print(n)
continue
s = 0
for elem in arr:
s += 1 if elem == "1" else 2
f_one = arr.index("1")
f_one = min(f_one, list(reversed(arr)).index("1"))
print(s - f_one)
|
IMPORT ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR IF STRING VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR VAR VAR VAR STRING NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR STRING EXPR FUNC_CALL VAR BIN_OP VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
c = a.count(1)
if c != 0:
i = 0
while a[i] == 2 and a[n - 1 - i] == 2:
i += 1
print(sum(a) - i)
else:
print(n)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER WHILE VAR VAR NUMBER VAR BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
T = int(input())
while T:
T -= 1
n = int(input())
a = [int(x) for x in input().split()]
c1 = a.count(1)
s = sum(a)
if c1 != 0:
if a[0] == 2 and a[-1] == 2:
ans = s - 1
else:
ans = s
else:
ans = n
print(ans)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER IF VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
T = int(input())
while T:
T -= 1
n = int(input())
a = [int(x) for x in input().split()]
ans = sum(a)
i = 0
while i < n:
if a[i] == 1 or a[n - i - 1] == 1:
break
ans -= 1
i += 1
print(ans)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER WHILE VAR VAR IF VAR VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
t = int(input())
for fuck in range(0, t):
n = int(input())
arr = list(map(int, input().strip().split()))
tot = sum(arr)
one = arr.count(1)
if tot % 2 == 0 and one == 0:
print(n)
elif tot % 2 == 1 and one == 1:
ind = arr.index(1)
final = min(ind, n - 1 - ind)
print(tot - final)
elif tot % 2 == 0 and one != 0:
print(tot)
else:
print(tot)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements [Bengali] , [Mandarin chinese] , [Russian] and [Vietnamese] as well.
For her birthday, Rima got an integer sequence $A_{1}, A_{2}, \dots, A_{N}$. Each element of this sequence is either 1 or 2.
Let's call an integer $s$ ($1 ≤ s ≤ 2N$) a *summary integer* if there is a contiguous subsequence of $A$ such that the sum of its elements is equal to $s$.
Rima wants to count all the summary integers. Can you help her?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing one integer — the number of summary integers.
------ Constraints ------
$1 ≤ T ≤ 5$
$1 ≤ N ≤ 2 \cdot 10^{6}$
$1 ≤ A_{i} ≤ 2$ for each valid $i$
----- Sample Input 1 ------
1
3
2 1 2
----- Sample Output 1 ------
4
|
def sum(a):
s = 0
for entry in a:
s = s + entry
return s
t = int(input())
for i in range(t):
first = 0
last = 0
n = int(input())
inp = list(map(int, input().split()))
flag = 0
for i in range(n):
if inp[i] == 1:
first = i
flag = 1
break
for i in range(n):
if inp[n - 1 - i] == 1:
last = n - 1 - i
flag = 1
break
if first >= n - last - 1 and flag == 1:
s = sum(inp[: last + 1]) + n - last - 1
elif n - last - 1 > first and flag == 1:
s = sum(inp[first:]) + first
else:
s = n
print(s)
|
FUNC_DEF ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR BIN_OP VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER ASSIGN VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR BIN_OP BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR ASSIGN VAR NUMBER IF VAR BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR NUMBER IF BIN_OP BIN_OP VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
import sys
from sys import stdin
try:
import sys
from sys import stdin
def indx(li, val):
f, l, ind = 0, len(li), -1
while f <= l and ind == -1:
mid = (f + l) // 2
if li[mid] == val:
ind = mid
elif val < li[mid]:
l = mid - 1
else:
f = mid + 1
return ind
def solveA(x, Y, ar, n):
max_h, min_h = 0, sys.maxsize
for i in range(n - 1):
max_h, min_h = max(x[i][1], max_h), min(x[i][1], min_h)
d1 = max_h - min_h
ind = indx(Y, x[i][1])
del Y[ind]
d2 = Y[-1] - Y[0]
new_ar = d1 * (x[i][0] - x[0][0]) + d2 * (x[n - 1][0] - x[i + 1][0])
ar = min(ar, new_ar)
return ar
def solveB(y, X, ar, n):
max_wd, min_wd = 0, sys.maxsize
for i in range(n - 1):
max_wd, min_wd = max(y[i][1], max_wd), min(y[i][1], min_wd)
d3 = max_wd - min_wd
ind = indx(X, y[i][1])
del X[ind]
d4 = X[-1] - X[0]
new_ar = d3 * (y[i][0] - y[0][0]) + d4 * (y[n - 1][0] - y[i + 1][0])
ar = min(ar, new_ar)
return ar
def solve(n):
x, y, X, Y, ar = [], [], [], [], sys.maxsize
for i in range(n):
a, b = map(int, sys.stdin.readline().split())
x.append([a, b]), y.append([b, a]), X.append(a), Y.append(b)
x.sort()
y.sort()
X.sort()
Y.sort()
re = solveA(x, Y, ar, n)
result = solveB(y, X, re, n)
if n == 1:
print(0)
else:
print(result)
def main():
for _ in range(int(sys.stdin.readline())):
n = int(sys.stdin.readline())
solve(n)
main()
except Exception:
pass
|
IMPORT IMPORT FUNC_DEF ASSIGN VAR VAR VAR NUMBER FUNC_CALL VAR VAR NUMBER WHILE VAR VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER IF VAR VAR VAR ASSIGN VAR VAR IF VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR VAR NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR VAR NUMBER VAR FUNC_CALL VAR VAR VAR NUMBER VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR NUMBER VAR VAR ASSIGN VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR VAR NUMBER VAR NUMBER NUMBER BIN_OP VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR VAR NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR VAR NUMBER VAR FUNC_CALL VAR VAR VAR NUMBER VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR NUMBER VAR VAR ASSIGN VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR VAR NUMBER VAR NUMBER NUMBER BIN_OP VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR VAR VAR VAR VAR LIST LIST LIST LIST VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR LIST VAR VAR FUNC_CALL VAR LIST VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
for _ in range(int(input())):
n = int(input())
points = []
for i in range(n):
points.append(tuple(map(int, input().split())))
if n <= 2:
print(0)
continue
A = float("inf")
X = list(sorted(points))
minpref, maxpref, minsuff, maxsuff = [X[0][1]], [X[0][1]], [X[-1][1]], [X[-1][1]]
for i in range(1, n):
minpref.append(min(minpref[i - 1], X[i][1]))
maxpref.append(max(maxpref[i - 1], X[i][1]))
minsuff.append(min(minsuff[i - 1], X[n - i - 1][1]))
maxsuff.append(max(maxsuff[i - 1], X[n - i - 1][1]))
for i in range(n - 1):
w0 = X[i][0] - X[0][0]
h0 = maxpref[i] - minpref[i]
w1 = X[n - 1][0] - X[i + 1][0]
h1 = maxsuff[n - i - 2] - minsuff[n - i - 2]
A = min(A, w0 * h0 + w1 * h1)
Y = list(sorted(points, key=lambda x: (x[1], x[0])))
minpref, maxpref, minsuff, maxsuff = [Y[0][0]], [Y[0][0]], [Y[-1][0]], [Y[-1][0]]
for i in range(1, n):
minpref.append(min(minpref[i - 1], Y[i][0]))
maxpref.append(max(maxpref[i - 1], Y[i][0]))
minsuff.append(min(minsuff[i - 1], Y[n - i - 1][0]))
maxsuff.append(max(maxsuff[i - 1], Y[n - i - 1][0]))
for i in range(n - 1):
w0 = maxpref[i] - minpref[i]
h0 = Y[i][1] - Y[0][1]
w1 = maxsuff[n - i - 2] - minsuff[n - i - 2]
h1 = Y[n - 1][1] - Y[i + 1][1]
A = min(A, w0 * h0 + w1 * h1)
print(A)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR LIST VAR NUMBER NUMBER LIST VAR NUMBER NUMBER LIST VAR NUMBER NUMBER LIST VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR NUMBER VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP BIN_OP VAR VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR NUMBER VAR NUMBER ASSIGN VAR VAR VAR VAR LIST VAR NUMBER NUMBER LIST VAR NUMBER NUMBER LIST VAR NUMBER NUMBER LIST VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR NUMBER VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP BIN_OP VAR VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
def helper2(sorted_points):
consolidated_points = []
curr_x = sorted_points[0][0]
min_y = sorted_points[0][1]
max_y = min_y
for x, y in sorted_points:
if curr_x == x:
min_y = min(min_y, y)
max_y = max(max_y, y)
else:
consolidated_points.append((curr_x, min_y, max_y))
curr_x = x
min_y = y
max_y = y
consolidated_points.append((curr_x, min_y, max_y))
return consolidated_points
def get_rectangle_areas(consolidated_points, x_inc=False):
min_x = consolidated_points[0][0]
max_x = min_x
min_y = consolidated_points[0][1]
max_y = consolidated_points[0][2]
areas = [0]
for x, y_lower, y_upper in consolidated_points:
if x_inc:
max_x = x
else:
min_x = x
min_y = min(min_y, y_lower)
max_y = max(max_y, y_upper)
areas.append((max_x - min_x) * (max_y - min_y))
return areas
def helper(points):
points.sort()
consolidated_points = helper2(points)
min_area = None
areas_left_to_right = get_rectangle_areas(consolidated_points, x_inc=True)
areas_right_to_left = get_rectangle_areas(consolidated_points[::-1], x_inc=False)[
::-1
]
for a1, a2 in zip(areas_left_to_right, areas_right_to_left):
area = a1 + a2
min_area = min(area, min_area) if min_area != None else area
return min_area
def solve(N):
x_points = []
y_points = []
for i in range(N):
x, y = map(int, input().split())
x_points.append((x, y))
y_points.append((y, x))
return min(helper(x_points), helper(y_points))
T = int(input())
for i in range(T):
print(solve(int(input())))
|
FUNC_DEF ASSIGN VAR LIST ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR FOR VAR VAR VAR IF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR RETURN VAR FUNC_DEF NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR LIST NUMBER FOR VAR VAR VAR VAR IF VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR BIN_OP VAR VAR RETURN VAR FUNC_DEF EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NONE ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR VAR NONE FUNC_CALL VAR VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
for i in range(int(input())):
n = int(input())
l = []
for i in range(n):
p = list(map(int, input().split()))
l.append(p)
l.sort()
y = []
for i in range(n):
y.append(l[i][1])
mx = -1
mn = 1000000000.0 + 1
ht = [[0, 0] for i in range(n)]
for i in range(n):
mx = max(mx, y[i])
mn = min(mn, y[i])
ht[i][0] = mx - mn
mx = -1
mn = 1000000000.0 + 1
for i in range(n - 1, 0, -1):
mx = max(mx, y[i])
mn = min(mn, y[i])
ht[i - 1][1] = mx - mn
a1 = 1e19
a2 = 1e19
for i in range(1, n):
a = (l[i - 1][0] - l[0][0]) * ht[i - 1][0] + (l[-1][0] - l[i][0]) * ht[i - 1][1]
a1 = min(a1, a)
for x in l:
x[0], x[1] = x[1], x[0]
l.sort()
x = []
for i in range(n):
x.append(l[i][1])
w = [[0, 0] for i in range(n)]
mx = -1
mn = 1000000000.0 + 1
for i in range(n):
mx = max(mx, x[i])
mn = min(mn, x[i])
w[i][0] = mx - mn
mx = -1
mn = 1000000000.0 + 1
for i in range(n - 1, 0, -1):
mx = max(mx, x[i])
mn = min(mn, x[i])
w[i - 1][1] = mx - mn
for i in range(1, n):
a = (l[i - 1][0] - l[0][0]) * w[i - 1][0] + (l[-1][0] - l[i][0]) * w[i - 1][1]
a2 = min(a2, a)
ans = min(a1, a2)
if ans >= 1e18 + 1:
print(0)
else:
print(ans)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR NUMBER BIN_OP VAR VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR NUMBER BIN_OP VAR VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR IF VAR BIN_OP NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
def area(rectangle):
[A, B] = rectangle
return abs(B[0] - A[0]) * abs(B[1] - A[1])
def solve(points):
if len(points) <= 2:
return 0
points_x = sorted(points, key=lambda x: x[0])
ymx = {}
for p in points_x:
if p[0] not in ymx:
ymx[p[0]] = [p[1], p[1]]
continue
if p[1] < ymx[p[0]][0]:
ymx[p[0]][0] = p[1]
elif p[1] > ymx[p[0]][1]:
ymx[p[0]][1] = p[1]
y_right = {points_x[-1][0]: ymx[points_x[-1][0]]}
for i in range(N - 2, -1, -1):
y_right[points_x[i][0]] = [
min(y_right[points_x[i + 1][0]][0], ymx[points_x[i][0]][0]),
max(y_right[points_x[i + 1][0]][1], ymx[points_x[i][0]][1]),
]
r1_x = [points_x[0][0], points_x[0][0]]
r2_x = [points_x[-1][0], points_x[-1][0]]
r1_y = [ymx[points_x[0][0]][0], ymx[points_x[0][0]][1]]
r2_y = [y_right[points_x[-1][0]][0], y_right[points_x[-1][0]][1]]
area_max = float("inf")
for i in range(N - 1):
r1_x[1] = points_x[i][0]
r2_x[0] = points_x[i + 1][0]
if r1_y[0] > ymx[points_x[i][0]][0]:
r1_y[0] = ymx[points_x[i][0]][0]
if r1_y[1] < ymx[points_x[i][0]][1]:
r1_y[1] = ymx[points_x[i][0]][1]
r2_y = y_right[points_x[i + 1][0]]
new_area = area([[r1_x[0], r1_y[0]], [r1_x[1], r1_y[1]]]) + area(
[[r2_x[0], r2_y[0]], [r2_x[1], r2_y[1]]]
)
if new_area < area_max:
area_max = new_area
points = [[y, x] for [x, y] in points]
points_x = sorted(points, key=lambda x: x[0])
ymx = {}
for p in points_x:
if p[0] not in ymx:
ymx[p[0]] = [p[1], p[1]]
continue
if p[1] < ymx[p[0]][0]:
ymx[p[0]][0] = p[1]
elif p[1] > ymx[p[0]][1]:
ymx[p[0]][1] = p[1]
y_right = {points_x[-1][0]: ymx[points_x[-1][0]]}
for i in range(N - 2, -1, -1):
y_right[points_x[i][0]] = [
min(y_right[points_x[i + 1][0]][0], ymx[points_x[i][0]][0]),
max(y_right[points_x[i + 1][0]][1], ymx[points_x[i][0]][1]),
]
r1_x = [points_x[0][0], points_x[0][0]]
r2_x = [points_x[-1][0], points_x[-1][0]]
r1_y = [ymx[points_x[0][0]][0], ymx[points_x[0][0]][1]]
r2_y = [y_right[points_x[-1][0]][0], y_right[points_x[-1][0]][1]]
full_rect = [
[points_x[0][0], y_right[points[0][0]][0]],
[points_x[-1][0], y_right[points[0][0]][1]],
]
for i in range(N - 1):
r1_x[1] = points_x[i][0]
r2_x[0] = points_x[i + 1][0]
if r1_y[0] > ymx[points_x[i][0]][0]:
r1_y[0] = ymx[points_x[i][0]][0]
if r1_y[1] < ymx[points_x[i][0]][1]:
r1_y[1] = ymx[points_x[i][0]][1]
r2_y = y_right[points_x[i + 1][0]]
new_area = area([[r1_x[0], r1_y[0]], [r1_x[1], r1_y[1]]]) + area(
[[r2_x[0], r2_y[0]], [r2_x[1], r2_y[1]]]
)
if new_area < area_max:
area_max = new_area
return area_max
for _ in range(int(input())):
N = int(input())
points = [[int(x) for x in input().split()] for i in range(N)]
print(solve(points))
|
FUNC_DEF ASSIGN LIST VAR VAR VAR RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER FUNC_DEF IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR DICT FOR VAR VAR IF VAR NUMBER VAR ASSIGN VAR VAR NUMBER LIST VAR NUMBER VAR NUMBER IF VAR NUMBER VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER VAR NUMBER IF VAR NUMBER VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR DICT VAR NUMBER NUMBER VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR NUMBER LIST FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER NUMBER NUMBER VAR VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER NUMBER NUMBER VAR VAR VAR NUMBER NUMBER ASSIGN VAR LIST VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR LIST VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR LIST VAR VAR NUMBER NUMBER NUMBER VAR VAR NUMBER NUMBER NUMBER ASSIGN VAR LIST VAR VAR NUMBER NUMBER NUMBER VAR VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR STRING FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER VAR VAR NUMBER ASSIGN VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER IF VAR NUMBER VAR VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER VAR VAR VAR NUMBER NUMBER IF VAR NUMBER VAR VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER VAR VAR VAR NUMBER NUMBER ASSIGN VAR VAR VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR LIST LIST VAR NUMBER VAR NUMBER LIST VAR NUMBER VAR NUMBER FUNC_CALL VAR LIST LIST VAR NUMBER VAR NUMBER LIST VAR NUMBER VAR NUMBER IF VAR VAR ASSIGN VAR VAR ASSIGN VAR LIST VAR VAR LIST VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR DICT FOR VAR VAR IF VAR NUMBER VAR ASSIGN VAR VAR NUMBER LIST VAR NUMBER VAR NUMBER IF VAR NUMBER VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER VAR NUMBER IF VAR NUMBER VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR DICT VAR NUMBER NUMBER VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR NUMBER LIST FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER NUMBER NUMBER VAR VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER NUMBER NUMBER VAR VAR VAR NUMBER NUMBER ASSIGN VAR LIST VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR LIST VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR LIST VAR VAR NUMBER NUMBER NUMBER VAR VAR NUMBER NUMBER NUMBER ASSIGN VAR LIST VAR VAR NUMBER NUMBER NUMBER VAR VAR NUMBER NUMBER NUMBER ASSIGN VAR LIST LIST VAR NUMBER NUMBER VAR VAR NUMBER NUMBER NUMBER LIST VAR NUMBER NUMBER VAR VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER VAR VAR NUMBER ASSIGN VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER IF VAR NUMBER VAR VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER VAR VAR VAR NUMBER NUMBER IF VAR NUMBER VAR VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER VAR VAR VAR NUMBER NUMBER ASSIGN VAR VAR VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR LIST LIST VAR NUMBER VAR NUMBER LIST VAR NUMBER VAR NUMBER FUNC_CALL VAR LIST LIST VAR NUMBER VAR NUMBER LIST VAR NUMBER VAR NUMBER IF VAR VAR ASSIGN VAR VAR RETURN VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
def func(arr):
n = len(arr)
if n == 1:
return 0
L1, R1, L2, R2 = (
[2000000000] * (n + 1),
[2000000000] * (n + 1),
[-2000000000] * (n + 1),
[-2000000000] * (n + 1),
)
res = 2000000000000000000
arr.sort()
for i in range(0, n):
L1[i] = arr[i][1]
L2[i] = arr[i][1]
if i:
L1[i] = min(L1[i - 1], L1[i])
L2[i] = max(L2[i - 1], L2[i])
for i in range(n - 1, -1, -1):
R1[i] = arr[i][1]
R2[i] = arr[i][1]
R1[i] = min(R1[i + 1], R1[i])
R2[i] = max(R2[i + 1], R2[i])
for i in range(0, n - 1):
res = min(
res,
(L2[i] - L1[i]) * (arr[i][0] - arr[0][0])
+ (R2[i + 1] - R1[i + 1]) * (arr[n - 1][0] - arr[i + 1][0]),
)
return res
tc = int(input())
for i in range(tc):
n = int(input())
arr1 = [[(0) for i in range(2)] for j in range(n)]
arr2 = [[(0) for i in range(2)] for j in range(n)]
for i in range(0, n):
arr1[i][0], arr1[i][1] = list(map(int, input().split()))
arr2[i][0] = arr1[i][1]
arr2[i][1] = arr1[i][0]
res1 = func(arr1)
res2 = func(arr2)
print(min(res1, res2))
|
FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER RETURN NUMBER ASSIGN VAR VAR VAR VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER BIN_OP LIST NUMBER BIN_OP VAR NUMBER BIN_OP LIST NUMBER BIN_OP VAR NUMBER BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER EXPR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR NUMBER IF VAR ASSIGN VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP BIN_OP BIN_OP VAR VAR VAR VAR BIN_OP VAR VAR NUMBER VAR NUMBER NUMBER BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR NUMBER VAR VAR NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
def VerticalLevels(array):
l = len(array)
array.append([0, array[-1][1] + 1])
ans = []
start, end = 0, 0
while end < l:
if array[end][1] == array[end + 1][1]:
end += 1
else:
ans.append(array[start : end + 1])
end += 1
start = end
return ans
def MinArea(Point, TopExtremes, BotExtremes):
levels = len(Point)
if levels == 1:
return 0
area1 = (TopExtremes[1][1] - TopExtremes[1][0]) * (
Point[levels - 1][0][1] - Point[1][0][1]
)
area2 = (BotExtremes[levels - 2][1] - BotExtremes[levels - 2][0]) * (
Point[levels - 2][0][1] - Point[0][0][1]
)
area = min(area1, area2)
for i in range(1, levels - 1):
level_i = Point[i]
l = len(level_i)
a1 = (TopExtremes[i][1] - TopExtremes[i][0]) * (
Point[-1][0][1] - Point[i][0][1]
)
a2 = (BotExtremes[i - 1][1] - BotExtremes[i - 1][0]) * (
Point[i - 1][0][1] - Point[0][0][1]
)
area = min(area, a1 + a2)
a1 = (TopExtremes[i + 1][1] - TopExtremes[i + 1][0]) * (
Point[-1][0][1] - Point[i + 1][0][1]
)
a2 = (BotExtremes[i][1] - BotExtremes[i][0]) * (Point[i][0][1] - Point[0][0][1])
area = min(area, a1 + a2)
for j in range(l - 1):
top_left = min(TopExtremes[i + 1][0], level_i[0][0])
top_right = max(TopExtremes[i + 1][1], level_i[j][0])
a1 = (top_right - top_left) * (Point[levels - 1][0][1] - Point[i][0][1])
bot_left = min(BotExtremes[i - 1][0], Point[i][j + 1][0])
bot_right = max(BotExtremes[i - 1][1], Point[i][-1][0])
a2 = (bot_right - bot_left) * (Point[i][0][1] - Point[0][0][1])
area = min(area, a1 + a2)
bot_left = min(BotExtremes[i - 1][0], Point[i][0][0])
bot_right = max(BotExtremes[i - 1][1], Point[i][j][0])
a1 = (bot_right - bot_left) * (Point[i][0][1] - Point[0][0][1])
top_left = min(TopExtremes[i + 1][0], Point[i][j + 1][0])
top_right = max(TopExtremes[i + 1][1], Point[i][-1][0])
a2 = (top_right - top_left) * (Point[-1][0][1] - Point[i][0][1])
area = min(area, a2 + a1)
return area
def EachCase():
n = int(input())
Point = [0] * n
for i in range(n):
Point[i] = list(map(int, input().split()))
Swapped = [0] * n
for i in range(n):
Swapped[i] = Point[i][::-1]
a = HorizontalCase(Point)
b = HorizontalCase(Swapped)
print(min(a, b))
def HorizontalCase(Point):
Point.sort(key=lambda x: [x[1], x[0]])
Point = VerticalLevels(Point)
levels = len(Point)
BotExtremes = [-1] * levels
BotExtremes[0] = [Point[0][0][0], Point[0][-1][0]]
for i in range(1, levels):
left, right = BotExtremes[i - 1]
BotExtremes[i] = [min(left, Point[i][0][0]), max(right, Point[i][-1][0])]
TopExtremes = [-1] * levels
TopExtremes[-1] = [Point[-1][0][0], Point[-1][-1][0]]
for i in range(levels - 2, -1, -1):
left, right = TopExtremes[i + 1]
TopExtremes[i] = [min(left, Point[i][0][0]), max(right, Point[i][-1][0])]
area = MinArea(Point, TopExtremes, BotExtremes)
return area
testCases = int(input())
for _ in range(testCases):
EachCase()
|
FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR LIST NUMBER BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR LIST ASSIGN VAR VAR NUMBER NUMBER WHILE VAR VAR IF VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER RETURN NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER NUMBER VAR NUMBER NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER VAR VAR NUMBER BIN_OP VAR NUMBER NUMBER NUMBER VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER VAR VAR NUMBER BIN_OP VAR VAR NUMBER NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER NUMBER VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR BIN_OP VAR VAR NUMBER NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR BIN_OP VAR VAR NUMBER NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR BIN_OP VAR NUMBER NUMBER NUMBER VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_DEF EXPR FUNC_CALL VAR LIST VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER LIST VAR NUMBER NUMBER NUMBER VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR LIST FUNC_CALL VAR VAR VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER LIST VAR NUMBER NUMBER NUMBER VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR LIST FUNC_CALL VAR VAR VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
def get_min_area_by_horizontal_split(points):
points.sort()
xs = [point[0] for point in points]
first_rectangle = [(points[0][1], points[0][1])]
for x, y in points[1:]:
bottom = min(first_rectangle[-1][0], y)
top = max(first_rectangle[-1][1], y)
first_rectangle.append((bottom, top))
first_heights = [(top - bottom) for bottom, top in first_rectangle]
second_rectangle = [(points[-1][1], points[-1][1])]
for x, y in points[-2::-1]:
bottom = min(second_rectangle[-1][0], y)
top = max(second_rectangle[-1][1], y)
second_rectangle.append((bottom, top))
second_rectangle = second_rectangle[::-1]
second_heights = [(top - bottom) for bottom, top in second_rectangle]
min_area = 10**18
first_left = xs[0]
second_right = xs[-1]
iterator = zip(xs[:-1], first_heights[:-1], xs[1:], second_heights[1:])
for first_right, first_height, second_left, second_height in iterator:
first_width = first_right - first_left
first_area = first_width * first_height
second_width = second_right - second_left
second_area = second_width * second_height
min_area = min(min_area, first_area + second_area)
return min_area
n_testcase = int(input())
for testcase in range(n_testcase):
n = int(input())
points = [tuple(int(x) for x in input().split()) for i in range(n)]
if n <= 2:
print(0)
continue
points_sorted_by_x = sorted(points)
points_sorted_by_y = sorted([(y, x) for x, y in points])
min_area = min(
get_min_area_by_horizontal_split(points_sorted_by_x),
get_min_area_by_horizontal_split(points_sorted_by_y),
)
print(min_area)
|
FUNC_DEF EXPR FUNC_CALL VAR ASSIGN VAR VAR NUMBER VAR VAR ASSIGN VAR LIST VAR NUMBER NUMBER VAR NUMBER NUMBER FOR VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR VAR ASSIGN VAR LIST VAR NUMBER NUMBER VAR NUMBER NUMBER FOR VAR VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP NUMBER NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FOR VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
INF = int(1e20)
def sweep_area(indices, X, Y):
minX = [INF] * N
maxX = [-1] * N
height = [0] * N
last_minX = INF
last_maxX = -1
y = Y[indices[0]]
for i in indices:
last_minX = min(last_minX, X[i])
last_maxX = max(last_maxX, X[i])
minX[i] = last_minX
maxX[i] = last_maxX
height[i] = abs(Y[i] - y)
return minX, maxX, height
def merge(curX, maxXtop, minXtop, maxXbot, minXbot, wBot, wTop, prevWbot):
maxX = max(curX)
minX = min(curX)
curMaxXtop = max(maxX, maxXtop)
curMinXtop = min(minX, minXtop)
curMinXbot = min(minX, minXbot)
area = (curMaxXtop - curMinXtop) * wTop + (maxXbot - minXbot) * prevWbot
last_x = curX[0]
for x in curX:
if minXtop < x:
continue
xBot = max(x, maxXbot)
xTop = min(last_x, minXtop)
area1 = (curMaxXtop - xTop) * wTop
area2 = (xBot - curMinXbot) * wBot
area = min(area, area1 + area2)
last_x = x
return area
def minimum_area(X, Y):
indices = list(range(N))
indices.sort(key=lambda i: (-Y[i], X[i]))
minXtop, maxXtop, heightTop = sweep_area(indices, X, Y)
indices.reverse()
minXbot, maxXbot, heightBot = sweep_area(indices, X, Y)
i_1 = indices[0]
x_indices = []
double_area = INF
j = -1
for i in indices + [INF]:
if i == INF or Y[i_1] != Y[i]:
if i == INF:
area = (maxXbot[j] - minXbot[j]) * heightBot[j]
elif j == -1:
area = (maxXtop[i] - minXtop[i]) * heightTop[i]
else:
curX = [X[k] for k in x_indices]
area1 = merge(
curX,
maxXtop[i],
minXtop[i],
maxXbot[j],
minXbot[j],
heightBot[i_1],
heightTop[i_1],
heightBot[j],
)
area2 = merge(
curX,
maxXbot[j],
minXbot[j],
maxXtop[i],
minXtop[i],
heightTop[i_1],
heightBot[i_1],
heightTop[i],
)
area = min(area1, area2)
double_area = min(double_area, area)
j = i_1
x_indices = []
x_indices.append(i)
i_1 = i
return double_area
def solve():
return min(minimum_area(X, Y), minimum_area(Y, X))
test_cases = int(input())
for test_case in range(test_cases):
N = int(input())
X = [0] * N
Y = [0] * N
for i in range(N):
X[i], Y[i] = map(int, input().split())
print(solve())
|
ASSIGN VAR FUNC_CALL VAR NUMBER FUNC_DEF ASSIGN VAR BIN_OP LIST VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR VAR ASSIGN VAR NUMBER ASSIGN VAR VAR VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR BIN_OP VAR VAR VAR RETURN VAR VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR VAR VAR BIN_OP BIN_OP VAR VAR VAR ASSIGN VAR VAR NUMBER FOR VAR VAR IF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR LIST ASSIGN VAR VAR ASSIGN VAR NUMBER FOR VAR BIN_OP VAR LIST VAR IF VAR VAR VAR VAR VAR VAR IF VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR VAR VAR VAR IF VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR LIST EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR RETURN VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
test = int(input())
for i in range(0, test):
n = int(input())
finall = []
for i in range(0, n):
lis = list(map(int, input().split()))
finall.append(lis)
if n <= 2:
print(0)
continue
final = sorted(finall)
max_pref = [final[0][1]]
min_pref = [final[0][1]]
max_suf = []
min_suf = []
for i in range(1, len(final)):
if final[i][1] > max_pref[i - 1]:
max_pref.append(final[i][1])
max_suf.append(0)
min_suf.append(0)
else:
max_pref.append(max_pref[i - 1])
max_suf.append(0)
min_suf.append(0)
if final[i][1] < min_pref[i - 1]:
min_pref.append(final[i][1])
max_suf.append(0)
min_suf.append(0)
else:
min_pref.append(min_pref[i - 1])
max_suf.append(0)
min_suf.append(0)
max_suf[len(final) - 1] = final[len(final) - 1][1]
min_suf[len(final) - 1] = final[len(final) - 1][1]
for j in range(len(final) - 2, -1, -1):
if final[j][1] > max_suf[j + 1]:
max_suf[j] = final[j][1]
else:
max_suf[j] = max_suf[j + 1]
if final[j][1] < min_suf[j + 1]:
min_suf[j] = final[j][1]
else:
min_suf[j] = min_suf[j + 1]
mini = (final[len(final) - 1][0] - final[0][0]) * (
max_pref[len(final) - 1] - min_pref[len(final) - 1]
)
for i in range(0, len(final) - 1):
width1 = final[i][0] - final[0][0]
height1 = max_pref[i] - min_pref[i]
width2 = final[len(final) - 1][0] - final[i + 1][0]
height2 = max_suf[i + 1] - min_suf[i + 1]
ans1 = width1 * height1 + width2 * height2
if ans1 < mini:
mini = ans1
final = sorted(finall, key=lambda x: x[1])
max_pref = [final[0][0]]
min_pref = [final[0][0]]
max_suf = []
min_suf = []
for i in range(1, len(final)):
if final[i][0] > max_pref[i - 1]:
max_pref.append(final[i][0])
max_suf.append(0)
min_suf.append(0)
else:
max_pref.append(max_pref[i - 1])
max_suf.append(0)
min_suf.append(0)
if final[i][0] < min_pref[i - 1]:
min_pref.append(final[i][0])
max_suf.append(0)
min_suf.append(0)
else:
min_pref.append(min_pref[i - 1])
max_suf.append(0)
min_suf.append(0)
max_suf[len(final) - 1] = final[len(final) - 1][0]
min_suf[len(final) - 1] = final[len(final) - 1][0]
for j in range(len(final) - 2, -1, -1):
if final[j][0] > max_suf[j + 1]:
max_suf[j] = final[j][0]
else:
max_suf[j] = max_suf[j + 1]
if final[j][0] < min_suf[j + 1]:
min_suf[j] = final[j][0]
else:
min_suf[j] = min_suf[j + 1]
mini2 = (final[len(final) - 1][1] - final[0][1]) * (
max_pref[len(final) - 1] - min_pref[len(final) - 1]
)
for i in range(0, len(final) - 1):
width1 = max_pref[i] - min_pref[i]
height1 = final[i][1] - final[0][1]
width2 = max_suf[i + 1] - min_suf[i + 1]
height2 = final[len(final) - 1][1] - final[i + 1][1]
ans1 = width1 * height1 + width2 * height2
if ans1 < mini2:
mini2 = ans1
print(min(mini, mini2))
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR LIST VAR NUMBER NUMBER ASSIGN VAR LIST VAR NUMBER NUMBER ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR IF VAR VAR NUMBER VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER IF VAR VAR NUMBER VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER NUMBER IF VAR VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR BIN_OP VAR NUMBER IF VAR VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER VAR NUMBER NUMBER BIN_OP VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR BIN_OP FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR NUMBER VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR BIN_OP VAR VAR IF VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR LIST VAR NUMBER NUMBER ASSIGN VAR LIST VAR NUMBER NUMBER ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR IF VAR VAR NUMBER VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER IF VAR VAR NUMBER VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER NUMBER IF VAR VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR BIN_OP VAR NUMBER IF VAR VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER VAR NUMBER NUMBER BIN_OP VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR BIN_OP FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR NUMBER VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR BIN_OP VAR VAR IF VAR VAR ASSIGN VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
import sys
input = sys.stdin.readline
T = int(input())
def solve(point):
point = sorted(point, key=lambda x: (-x[1], x[0]))
n = len(point)
if n == 1:
return 0
Lx = [[0, 0] for _ in range(n)]
Ly = [[0, 0] for _ in range(n)]
Rx = [[0, 0] for _ in range(n)]
Ry = [[0, 0] for _ in range(n)]
Lx[0][0] = Rx[0][0] = point[0][0]
Ly[0][0] = Ry[0][0] = point[0][1]
for i in range(1, n):
Lx[i][0] = min(Lx[i - 1][0], point[i][0])
Rx[i][0] = max(Rx[i - 1][0], point[i][0])
Ly[i][0] = min(Ly[i - 1][0], point[i][1])
Ry[i][0] = max(Ry[i - 1][0], point[i][1])
Lx[n - 1][1] = Rx[n - 1][1] = point[n - 1][0]
Ly[n - 1][1] = Ry[n - 1][1] = point[n - 1][1]
for i in range(n - 2, -1, -1):
Lx[i][1] = min(Lx[i + 1][1], point[i][0])
Rx[i][1] = max(Rx[i + 1][1], point[i][0])
Ly[i][1] = min(Ly[i + 1][1], point[i][1])
Ry[i][1] = max(Ry[i + 1][1], point[i][1])
ans = 10**18
s = [[0, 0] for _ in range(n)]
for i in range(n):
s[i][0] = (Rx[i][0] - Lx[i][0]) * (Ry[i][0] - Ly[i][0])
s[i][1] = (Rx[i][1] - Lx[i][1]) * (Ry[i][1] - Ly[i][1])
if i:
ans = min(ans, s[i][1] + s[i - 1][0])
return ans
for tt in range(T):
n = int(input())
point = [[0, 0] for _ in range(n)]
for i in range(n):
point[i][0], point[i][1] = map(int, input().split())
ans = solve(point)
for i in range(n):
point[i] = [point[i][1], point[i][0]]
ans = min(ans, solve(point))
print(ans)
|
IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER RETURN NUMBER ASSIGN VAR LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR NUMBER FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER ASSIGN VAR VAR NUMBER FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER ASSIGN VAR VAR NUMBER FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER ASSIGN VAR VAR NUMBER FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER ASSIGN VAR VAR NUMBER FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER ASSIGN VAR VAR NUMBER FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER ASSIGN VAR VAR NUMBER FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER ASSIGN VAR BIN_OP NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER VAR VAR NUMBER BIN_OP VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER VAR VAR NUMBER BIN_OP VAR VAR NUMBER VAR VAR NUMBER IF VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER RETURN VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER VAR VAR NUMBER FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR LIST VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
def getmm(points, c):
ans = [(points[0][c], points[0][c])]
ansr = [(points[-1][c], points[-1][c])]
for p in points[1:]:
ans.append((min(p[c], ans[-1][0]), max(p[c], ans[-1][1])))
for p in points[-2::-1]:
ansr.append((min(p[c], ansr[-1][0]), max(p[c], ansr[-1][1])))
return ans, ansr[::-1]
te = int(input())
while te != 0:
te -= 1
points = []
n = int(input())
for i in range(n):
points.append(list(map(int, input().split())))
p_x = sorted(points, key=lambda x: x[0])
p_y = sorted(points, key=lambda x: x[1])
mmx, mmx_r = getmm(p_y, 0)
mmy, mmy_r = getmm(p_x, 1)
ans = float("inf")
l, r = p_x[0][0], p_x[-1][0]
for i in range(1, n):
r1 = (p_x[i - 1][0] - l) * (mmy[i - 1][1] - mmy[i - 1][0])
r2 = (r - p_x[i][0]) * (mmy_r[i][1] - mmy_r[i][0])
ans = min(r1 + r2, ans)
b, t = p_y[0][1], p_y[-1][1]
for i in range(1, n):
r1 = (p_y[i - 1][1] - b) * (mmx[i - 1][1] - mmx[i - 1][0])
r2 = (t - p_y[i][1]) * (mmx_r[i][1] - mmx_r[i][0])
ans = min(r1 + r2, ans)
print(0 if ans == float("inf") else ans)
|
FUNC_DEF ASSIGN VAR LIST VAR NUMBER VAR VAR NUMBER VAR ASSIGN VAR LIST VAR NUMBER VAR VAR NUMBER VAR FOR VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR VAR VAR NUMBER NUMBER FOR VAR VAR NUMBER NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR VAR VAR NUMBER NUMBER RETURN VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER VAR NUMBER ASSIGN VAR LIST ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR VAR VAR NUMBER NUMBER VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR NUMBER BIN_OP VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR VAR VAR ASSIGN VAR VAR VAR NUMBER NUMBER VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR NUMBER BIN_OP VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR FUNC_CALL VAR STRING NUMBER VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
def maximum(arr1, index):
return max(arr1, key=lambda a: a[not index])[not index]
def minimum(arr1, index):
return min(arr1, key=lambda a: a[not index])[not index]
def prefix_suffix(arr):
prefix_min = [0] * (len(arr) + 2)
suffix_min = [0] * (len(arr) + 2)
prefix_max = [0] * (len(arr) + 2)
suffix_max = [0] * (len(arr) + 2)
prefix_min[0] = float("inf")
suffix_min[-1] = float("inf")
for i in range(1, len(arr) + 1):
prefix = arr[i - 1]
suffix = arr[-i]
prefix_min[i] = min(prefix_min[i - 1], prefix)
prefix_max[i] = max(prefix_max[i - 1], prefix)
suffix_min[-i - 1] = min(suffix_min[-i], suffix)
suffix_max[-i - 1] = max(suffix_max[-i], suffix)
return prefix_min, prefix_max, suffix_min, suffix_max
t = int(input())
for _ in range(t):
n = int(input())
arr = []
for _ in range(n):
point = list(map(int, input().split()))
arr.append(point)
if n == 1:
print(0)
else:
x_sort = sorted(arr, key=lambda a: a[0])
y_sort = sorted(arr, key=lambda b: b[1])
area_x = float("inf")
x = prefix_suffix(list(map(lambda a: a[1], x_sort)))
prefix_min_x = x[0]
prefix_max_x = x[1]
suffix_min_x = x[2]
suffix_max_x = x[3]
for i in range(1, n):
x_1 = (prefix_max_x[i] - prefix_min_x[i]) * (
x_sort[i - 1][0] - x_sort[0][0]
)
x_2 = (suffix_max_x[i + 1] - suffix_min_x[i + 1]) * (
x_sort[-1][0] - x_sort[i][0]
)
area_x = min(area_x, x_1 + x_2)
area_y = float("inf")
y = prefix_suffix(list(map(lambda a: a[0], y_sort)))
prefix_min_y = y[0]
prefix_max_y = y[1]
suffix_min_y = y[2]
suffix_max_y = y[3]
for i in range(1, n):
y_1 = (prefix_max_y[i] - prefix_min_y[i]) * (
y_sort[i - 1][1] - y_sort[0][1]
)
y_2 = (suffix_max_y[i + 1] - suffix_min_y[i + 1]) * (
y_sort[-1][1] - y_sort[i][1]
)
area_y = min(area_y, y_1 + y_2)
print(int(min(area_x, area_y)))
|
FUNC_DEF RETURN FUNC_CALL VAR VAR VAR VAR VAR FUNC_DEF RETURN FUNC_CALL VAR VAR VAR VAR VAR FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER FUNC_CALL VAR STRING ASSIGN VAR NUMBER FUNC_CALL VAR STRING FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR ASSIGN VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR ASSIGN VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
import sys
def compute_dp(points):
dp = []
ax, min_y = points[0]
max_y = min_y
for p in points:
bx, by = p
min_y = min(by, min_y)
max_y = max(by, max_y)
area = abs(bx - ax) * abs(max_y - min_y)
dp.append(area)
return dp
def compute_min_area(N, points):
sorted_x = sorted(points, key=lambda p: p[0])
dp = compute_dp(sorted_x)
sorted_x.reverse()
dp_r = compute_dp(sorted_x)
dp_r.reverse()
min_area = dp[N - 1]
for i in range(N - 1):
min_area = min(min_area, dp[i] + dp_r[i + 1])
return min_area
t = int(sys.stdin.readline())
for _ in range(t):
N = int(sys.stdin.readline())
points = []
for _ in range(N):
p = tuple(map(int, sys.stdin.readline().split()))
points.append(p)
if N <= 2:
print(0)
continue
min_area_x = compute_min_area(N, points)
points_transposed = map(lambda p: (p[1], p[0]), points)
min_area_y = compute_min_area(N, points_transposed)
print(min(min_area_x, min_area_y))
|
IMPORT FUNC_DEF ASSIGN VAR LIST ASSIGN VAR VAR VAR NUMBER ASSIGN VAR VAR FOR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
inf = float("inf")
for _ in range(int(input())):
minX = {}
maxX = {}
minY = {}
maxY = {}
n = int(input())
for i in range(n):
x, y = map(int, input().split())
minY[x] = min(minY.get(x, inf), y)
maxY[x] = max(maxY.get(x, -inf), y)
minX[y] = min(minX.get(y, inf), x)
maxX[y] = max(maxX.get(y, -inf), x)
X = sorted(list(minY.keys()))
Y = sorted(list(minX.keys()))
area = inf
rect_from_start, rect_from_end = [], []
top, bottom = -inf, inf
for x in X:
top = max(top, maxY[x])
bottom = min(bottom, minY[x])
rect_from_start.append((x - X[0]) * (top - bottom))
top, bottom = -inf, inf
for x in X[::-1]:
top = max(top, maxY[x])
bottom = min(bottom, minY[x])
rect_from_end.append((X[-1] - x) * (top - bottom))
rect_from_end.reverse()
rect_from_end.append(0)
for i in range(len(X)):
area = min(area, rect_from_end[i + 1] + rect_from_start[i])
rect_from_start, rect_from_end = [], []
top, bottom = -inf, inf
for y in Y:
top = max(top, maxX[y])
bottom = min(bottom, minX[y])
rect_from_start.append((y - Y[0]) * (top - bottom))
top, bottom = -inf, inf
for y in Y[::-1]:
top = max(top, maxX[y])
bottom = min(bottom, minX[y])
rect_from_end.append((Y[-1] - y) * (top - bottom))
rect_from_end.reverse()
rect_from_end.append(0)
for i in range(len(Y)):
area = min(area, rect_from_end[i + 1] + rect_from_start[i])
print(area)
|
ASSIGN VAR FUNC_CALL VAR STRING FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR DICT ASSIGN VAR DICT ASSIGN VAR DICT ASSIGN VAR DICT ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR ASSIGN VAR VAR LIST LIST ASSIGN VAR VAR VAR VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER BIN_OP VAR VAR ASSIGN VAR VAR VAR VAR FOR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR VAR LIST LIST ASSIGN VAR VAR VAR VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER BIN_OP VAR VAR ASSIGN VAR VAR VAR VAR FOR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
def height(A, n):
a = []
mn = 1000000000.0 + 1
mx = -1
for i in range(n - 1):
if A[i] < mn:
mn = A[i]
if A[i] > mx:
mx = A[i]
a.append(mx - mn)
return a
def sort(L):
return sorted(L, key=lambda x: x[0])
def fun(A, n):
l2 = []
for i in range(n):
l2.append(A[i][1])
h1 = height(l2, n)
h2 = height(l2[::-1], n)
h2 = h2[::-1]
area = 1e19 + 1
for i in range(n - 1):
temp = h1[i] * (A[i][0] - A[0][0]) + h2[i] * (A[-1][0] - A[i + 1][0])
if temp < area:
area = temp
if area == 1e19:
return 0
else:
return area
for i in range(int(input())):
n = int(input())
Lx, Ly = [], []
for i in range(n):
a, b = map(int, input().split())
Lx.append([a, b])
Ly.append([b, a])
Lx = sort(Lx)
Ly = sort(Ly)
area1 = fun(Lx, n)
area2 = fun(Ly, n)
print(min(area1, area2))
|
FUNC_DEF ASSIGN VAR LIST ASSIGN VAR BIN_OP NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR ASSIGN VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR RETURN VAR FUNC_DEF RETURN FUNC_CALL VAR VAR VAR NUMBER FUNC_DEF ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER VAR ASSIGN VAR VAR NUMBER ASSIGN VAR BIN_OP NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR BIN_OP VAR VAR NUMBER VAR NUMBER NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER IF VAR VAR ASSIGN VAR VAR IF VAR NUMBER RETURN NUMBER RETURN VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR LIST LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR LIST VAR VAR EXPR FUNC_CALL VAR LIST VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Read problem statements in [Vietnamese],
[Bengali], [Mandarin Chinese], and [Russian] as well.
Given $N$ points in a $2D$ space, find the minimum sum of areas of rectangles required to cover all the points given that we can use at most $2$ non-overlapping rectangles whose sides can touch. The rectangles must be axis-aligned, meaning the sides are vertical and horizontal.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains $N + 1$ lines of input.
The first line contains a single integer $N$, the number of points.
The next $N$ lines each contains two integers $x_{i}$, $y_{i}$, the coordinates of the $i$-th point.
Note: Points need not be distinct.
------ Output ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ x_{i}, y_{i} ≤ 10^{9}$
The sum of $N$ over all test cases is at most $10^{5}$.
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
3
1
100 100
4
1 100
100 100
100 1
1 1
5
1 100
100 100
100 1
1 1
50 50
----- Sample Output 1 ------
0
0
4851
----- explanation 1 ------
Case 1: Since there is only one point, the minimum area of a rectangle to cover this point is $0$.
Case 2: We can have rectangles as $2$ opposite sides of the square. Since the width of the rectangles is $0$, the total area is also $0$.
Case 3: The optimal solution is with the rectangles having endpoints $\{(1, 1), (100, 1), (1, 50), (100, 50)\}$ and $\{(1, 100), (1, 100), (100, 100), (100, 100)\}$. Therefore the total area is $49 \cdot 99 + 0 \cdot 99 = 4851$
|
def solve2(coordinates):
coordinates.sort()
minX = coordinates[0][0]
maxX = coordinates[-1][0]
minY = coordinates[0][1]
maxY = coordinates[0][1]
size_left = [(0) for i in range(len(coordinates) + 1)]
for idx, (x, y) in enumerate(coordinates):
minY = min(minY, y)
maxY = max(maxY, y)
size_left[idx + 1] = maxY - minY
minY = coordinates[-1][1]
maxY = coordinates[-1][1]
size_right = [(0) for i in range(len(coordinates) + 1)]
for idx, (x, y) in reversed(list(enumerate(coordinates))):
minY = min(minY, y)
maxY = max(maxY, y)
size_right[idx] = maxY - minY
answer = (maxX - coordinates[0][0]) * size_right[0]
for idx in range(1, len(coordinates)):
left_rectangle = (coordinates[idx - 1][0] - minX) * size_left[idx]
right_rectangle = (maxX - coordinates[idx][0]) * size_right[idx]
answer = min(answer, left_rectangle + right_rectangle)
return answer
def solve(t):
N = int(input())
coordinates = []
for i in range(N):
x, y = map(int, input().split())
coordinates.append((x, y))
answer = solve2(coordinates)
coordinates = [(y, x) for x, y in coordinates]
answer = min(answer, solve2(coordinates))
print(answer)
T = int(input())
for t in range(T):
solve(t + 1)
|
FUNC_DEF EXPR FUNC_CALL VAR ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER FOR VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER FOR VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER
|
Read problems statements in Mandarin Chinese, Russian and Vietnamese as well.
Little Egor likes to play with positive integers and their divisors. Bigger the number to play with, more the fun! The boy asked you to come up with an algorithm, that could play the following game:
Let's define f(n) as the sum of all odd divisors of n. I.e. f(10) = 1 + 5 = 6 and f(21) = 1 + 3 + 7 + 21 = 32. The game is to calculate f(l) + f(l + 1) + ... + f(r - 1) + f(r) for the given integers l and r.
Have fun! But be careful, the integers might be quite big.
------ Input ------
The first line of the input contains one integer T denoting the number of test cases.
The only line of the test case description contains two positive integers l and r.
------ Output ------
For each test case, output the required sum on a separate line.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ l ≤ r ≤ 10^{5}$
----- Sample Input 1 ------
2
1 10
42 42
----- Sample Output 1 ------
45
32
----- explanation 1 ------
In the first example case, f(1) + f(2) + ... + f(10) = 1 + 1 + 4 + 1 + 6 + 4 + 8 + 1 + 13 + 6 = 45
In the second example case, f(42) = 32.
|
test_case = int(input())
for i in range(test_case):
l, r = map(int, input().split())
count = 0
for j in range(1, r + 1, 2):
m = l % j
if m == 0:
x = l
else:
x = l + (j - m)
if x in range(l, r + 1):
count += ((r - x) // j + 1) * j
print(count)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER ASSIGN VAR VAR ASSIGN VAR BIN_OP VAR BIN_OP VAR VAR IF VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP BIN_OP BIN_OP VAR VAR VAR NUMBER VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in Mandarin Chinese, Russian and Vietnamese as well.
Little Egor likes to play with positive integers and their divisors. Bigger the number to play with, more the fun! The boy asked you to come up with an algorithm, that could play the following game:
Let's define f(n) as the sum of all odd divisors of n. I.e. f(10) = 1 + 5 = 6 and f(21) = 1 + 3 + 7 + 21 = 32. The game is to calculate f(l) + f(l + 1) + ... + f(r - 1) + f(r) for the given integers l and r.
Have fun! But be careful, the integers might be quite big.
------ Input ------
The first line of the input contains one integer T denoting the number of test cases.
The only line of the test case description contains two positive integers l and r.
------ Output ------
For each test case, output the required sum on a separate line.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ l ≤ r ≤ 10^{5}$
----- Sample Input 1 ------
2
1 10
42 42
----- Sample Output 1 ------
45
32
----- explanation 1 ------
In the first example case, f(1) + f(2) + ... + f(10) = 1 + 1 + 4 + 1 + 6 + 4 + 8 + 1 + 13 + 6 = 45
In the second example case, f(42) = 32.
|
for i in range(int(input())):
a, b = list(map(int, input().split()))
c = sum(j * (b // j) for j in range(1, b + 1, 2))
d = sum(j * ((a - 1) // j) for j in range(1, a, 2))
print(c - d)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR BIN_OP VAR VAR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER VAR VAR FUNC_CALL VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR
|
Read problems statements in Mandarin Chinese, Russian and Vietnamese as well.
Little Egor likes to play with positive integers and their divisors. Bigger the number to play with, more the fun! The boy asked you to come up with an algorithm, that could play the following game:
Let's define f(n) as the sum of all odd divisors of n. I.e. f(10) = 1 + 5 = 6 and f(21) = 1 + 3 + 7 + 21 = 32. The game is to calculate f(l) + f(l + 1) + ... + f(r - 1) + f(r) for the given integers l and r.
Have fun! But be careful, the integers might be quite big.
------ Input ------
The first line of the input contains one integer T denoting the number of test cases.
The only line of the test case description contains two positive integers l and r.
------ Output ------
For each test case, output the required sum on a separate line.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ l ≤ r ≤ 10^{5}$
----- Sample Input 1 ------
2
1 10
42 42
----- Sample Output 1 ------
45
32
----- explanation 1 ------
In the first example case, f(1) + f(2) + ... + f(10) = 1 + 1 + 4 + 1 + 6 + 4 + 8 + 1 + 13 + 6 = 45
In the second example case, f(42) = 32.
|
for _ in range(int(input())):
a, b = map(int, input().split())
sum = 0
a = a - 1
for i in range(1, b + 1, 2):
sum += (b // i - a // i) * i
print(sum)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER NUMBER VAR BIN_OP BIN_OP BIN_OP VAR VAR BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in Mandarin Chinese, Russian and Vietnamese as well.
Little Egor likes to play with positive integers and their divisors. Bigger the number to play with, more the fun! The boy asked you to come up with an algorithm, that could play the following game:
Let's define f(n) as the sum of all odd divisors of n. I.e. f(10) = 1 + 5 = 6 and f(21) = 1 + 3 + 7 + 21 = 32. The game is to calculate f(l) + f(l + 1) + ... + f(r - 1) + f(r) for the given integers l and r.
Have fun! But be careful, the integers might be quite big.
------ Input ------
The first line of the input contains one integer T denoting the number of test cases.
The only line of the test case description contains two positive integers l and r.
------ Output ------
For each test case, output the required sum on a separate line.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ l ≤ r ≤ 10^{5}$
----- Sample Input 1 ------
2
1 10
42 42
----- Sample Output 1 ------
45
32
----- explanation 1 ------
In the first example case, f(1) + f(2) + ... + f(10) = 1 + 1 + 4 + 1 + 6 + 4 + 8 + 1 + 13 + 6 = 45
In the second example case, f(42) = 32.
|
x = int(input())
divisors = [[] for _ in range(1000001)]
for i in range(1, 1000001, 2):
for j in range(i, 1000001, i):
divisors[j].append(i)
cache = {}
for c in range(x):
a, b = map(int, input().split())
if (a, b) in cache:
print(cache[a, b])
continue
s = 0
for d in range(a, b + 1):
s += sum(divisors[d])
cache[a, b] = s
print(s)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR DICT FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in Mandarin Chinese, Russian and Vietnamese as well.
Little Egor likes to play with positive integers and their divisors. Bigger the number to play with, more the fun! The boy asked you to come up with an algorithm, that could play the following game:
Let's define f(n) as the sum of all odd divisors of n. I.e. f(10) = 1 + 5 = 6 and f(21) = 1 + 3 + 7 + 21 = 32. The game is to calculate f(l) + f(l + 1) + ... + f(r - 1) + f(r) for the given integers l and r.
Have fun! But be careful, the integers might be quite big.
------ Input ------
The first line of the input contains one integer T denoting the number of test cases.
The only line of the test case description contains two positive integers l and r.
------ Output ------
For each test case, output the required sum on a separate line.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ l ≤ r ≤ 10^{5}$
----- Sample Input 1 ------
2
1 10
42 42
----- Sample Output 1 ------
45
32
----- explanation 1 ------
In the first example case, f(1) + f(2) + ... + f(10) = 1 + 1 + 4 + 1 + 6 + 4 + 8 + 1 + 13 + 6 = 45
In the second example case, f(42) = 32.
|
def sieve_divisors(n):
divisors = [0] * (n + 1)
for i in range(1, n + 1):
if i % 2 == 0:
continue
for j in range(i, n + 1, i):
divisors[j] += i
return divisors
def prefix_sum(divisors):
prefix = [0] * len(divisors)
for i in range(1, len(divisors)):
prefix[i] = prefix[i - 1] + divisors[i]
return prefix
t = int(input())
for _ in range(t):
l, r = map(int, input().split())
divisors = sieve_divisors(r)
prefix = prefix_sum(divisors)
result = prefix[r] - prefix[l - 1]
print(result)
|
FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR
|
Read problems statements in Mandarin Chinese, Russian and Vietnamese as well.
Little Egor likes to play with positive integers and their divisors. Bigger the number to play with, more the fun! The boy asked you to come up with an algorithm, that could play the following game:
Let's define f(n) as the sum of all odd divisors of n. I.e. f(10) = 1 + 5 = 6 and f(21) = 1 + 3 + 7 + 21 = 32. The game is to calculate f(l) + f(l + 1) + ... + f(r - 1) + f(r) for the given integers l and r.
Have fun! But be careful, the integers might be quite big.
------ Input ------
The first line of the input contains one integer T denoting the number of test cases.
The only line of the test case description contains two positive integers l and r.
------ Output ------
For each test case, output the required sum on a separate line.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ l ≤ r ≤ 10^{5}$
----- Sample Input 1 ------
2
1 10
42 42
----- Sample Output 1 ------
45
32
----- explanation 1 ------
In the first example case, f(1) + f(2) + ... + f(10) = 1 + 1 + 4 + 1 + 6 + 4 + 8 + 1 + 13 + 6 = 45
In the second example case, f(42) = 32.
|
T = int(input())
for i in range(T):
f1 = 0
f2 = 0
l, r = list(map(int, input().split()))
for j in range(1, r + 1, 2):
f2 += j * (r // j)
for j in range(1, l, 2):
f1 += j * ((l - 1) // j)
print(f2 - f1)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR BIN_OP VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR NUMBER VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR
|
Read problems statements in Mandarin Chinese, Russian and Vietnamese as well.
Little Egor likes to play with positive integers and their divisors. Bigger the number to play with, more the fun! The boy asked you to come up with an algorithm, that could play the following game:
Let's define f(n) as the sum of all odd divisors of n. I.e. f(10) = 1 + 5 = 6 and f(21) = 1 + 3 + 7 + 21 = 32. The game is to calculate f(l) + f(l + 1) + ... + f(r - 1) + f(r) for the given integers l and r.
Have fun! But be careful, the integers might be quite big.
------ Input ------
The first line of the input contains one integer T denoting the number of test cases.
The only line of the test case description contains two positive integers l and r.
------ Output ------
For each test case, output the required sum on a separate line.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ l ≤ r ≤ 10^{5}$
----- Sample Input 1 ------
2
1 10
42 42
----- Sample Output 1 ------
45
32
----- explanation 1 ------
In the first example case, f(1) + f(2) + ... + f(10) = 1 + 1 + 4 + 1 + 6 + 4 + 8 + 1 + 13 + 6 = 45
In the second example case, f(42) = 32.
|
for i in range(int(input())):
n, m = map(int, input().split())
sum1 = 0
sum2 = 0
for i in range(1, m + 1, 2):
sum1 = sum1 + i * (m // i)
for i in range(1, n, 2):
sum2 = sum2 + i * ((n - 1) // i)
print(sum1 - sum2)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR BIN_OP VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR
|
Read problems statements in Mandarin Chinese, Russian and Vietnamese as well.
Little Egor likes to play with positive integers and their divisors. Bigger the number to play with, more the fun! The boy asked you to come up with an algorithm, that could play the following game:
Let's define f(n) as the sum of all odd divisors of n. I.e. f(10) = 1 + 5 = 6 and f(21) = 1 + 3 + 7 + 21 = 32. The game is to calculate f(l) + f(l + 1) + ... + f(r - 1) + f(r) for the given integers l and r.
Have fun! But be careful, the integers might be quite big.
------ Input ------
The first line of the input contains one integer T denoting the number of test cases.
The only line of the test case description contains two positive integers l and r.
------ Output ------
For each test case, output the required sum on a separate line.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ l ≤ r ≤ 10^{5}$
----- Sample Input 1 ------
2
1 10
42 42
----- Sample Output 1 ------
45
32
----- explanation 1 ------
In the first example case, f(1) + f(2) + ... + f(10) = 1 + 1 + 4 + 1 + 6 + 4 + 8 + 1 + 13 + 6 = 45
In the second example case, f(42) = 32.
|
def factor(n):
sum = 0
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
if i % 2 != 0:
sum += i
if n // i != i and n // i % 2 != 0:
sum += n // i
return sum
factor_sums = [0] * (10**5 + 1)
for i in range(1, len(factor_sums)):
factor_sums[i] = factor_sums[i - 1] + factor(i)
t = int(input())
for i in range(t):
a, x = map(int, input().split())
print(factor_sums[x] - factor_sums[a - 1])
|
FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER IF BIN_OP VAR VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR VAR IF BIN_OP VAR VAR VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER VAR BIN_OP VAR VAR RETURN VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP BIN_OP NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR VAR BIN_OP VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER
|
Read problems statements in Mandarin Chinese, Russian and Vietnamese as well.
Little Egor likes to play with positive integers and their divisors. Bigger the number to play with, more the fun! The boy asked you to come up with an algorithm, that could play the following game:
Let's define f(n) as the sum of all odd divisors of n. I.e. f(10) = 1 + 5 = 6 and f(21) = 1 + 3 + 7 + 21 = 32. The game is to calculate f(l) + f(l + 1) + ... + f(r - 1) + f(r) for the given integers l and r.
Have fun! But be careful, the integers might be quite big.
------ Input ------
The first line of the input contains one integer T denoting the number of test cases.
The only line of the test case description contains two positive integers l and r.
------ Output ------
For each test case, output the required sum on a separate line.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ l ≤ r ≤ 10^{5}$
----- Sample Input 1 ------
2
1 10
42 42
----- Sample Output 1 ------
45
32
----- explanation 1 ------
In the first example case, f(1) + f(2) + ... + f(10) = 1 + 1 + 4 + 1 + 6 + 4 + 8 + 1 + 13 + 6 = 45
In the second example case, f(42) = 32.
|
def primeFactors(n):
a = 1
while n % 2 == 0:
n = n // 2
for i in range(3, int(n**0.5) + 1, 2):
j = 1
s = 1
while n % i == 0:
n = n // i
s += j * i
j = j * i
a *= s
if n > 2:
a = a * (1 + n)
return a
A = [0] * 100001
for i in range(1, 100001):
A[i] = primeFactors(i)
T = int(input())
for t in range(T):
l, r = map(int, input().strip().split())
print(sum(A[l : r + 1]))
|
FUNC_DEF ASSIGN VAR NUMBER WHILE BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR IF VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP NUMBER VAR RETURN VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER
|
Read problems statements in Mandarin Chinese, Russian and Vietnamese as well.
Little Egor likes to play with positive integers and their divisors. Bigger the number to play with, more the fun! The boy asked you to come up with an algorithm, that could play the following game:
Let's define f(n) as the sum of all odd divisors of n. I.e. f(10) = 1 + 5 = 6 and f(21) = 1 + 3 + 7 + 21 = 32. The game is to calculate f(l) + f(l + 1) + ... + f(r - 1) + f(r) for the given integers l and r.
Have fun! But be careful, the integers might be quite big.
------ Input ------
The first line of the input contains one integer T denoting the number of test cases.
The only line of the test case description contains two positive integers l and r.
------ Output ------
For each test case, output the required sum on a separate line.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ l ≤ r ≤ 10^{5}$
----- Sample Input 1 ------
2
1 10
42 42
----- Sample Output 1 ------
45
32
----- explanation 1 ------
In the first example case, f(1) + f(2) + ... + f(10) = 1 + 1 + 4 + 1 + 6 + 4 + 8 + 1 + 13 + 6 = 45
In the second example case, f(42) = 32.
|
t = int(input())
for _ in range(t):
l, r = map(int, input().split())
sum1 = 0
for i in range(1, r + 1, 2):
sum1 += i * (r // i)
sum2 = 0
for i in range(1, l, 2):
sum2 += i * ((l - 1) // i)
print(sum1 - sum2)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR BIN_OP VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR NUMBER VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
def solve():
n = int(input())
arr = list(map(int, input().split()))
freq = {}
acc = 0
l, r = -1, -1
for i in range(n):
acc += arr[i]
acc %= n
if acc == 0:
l, r = 1, i + 1
break
elif acc in freq:
l, r = freq[acc] + 1, i + 1
break
freq[acc] = i + 1
print(r - l + 1)
for i in range(l, r + 1):
print(i, end=" ")
print()
for t in range(int(input())):
solve()
|
FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR DICT ASSIGN VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR IF VAR NUMBER ASSIGN VAR VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR STRING EXPR FUNC_CALL VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
import sys
P = [0] * 100010
t = int(sys.stdin.readline())
for _ in range(t):
n = int(sys.stdin.readline())
arr = list(map(int, sys.stdin.readline().split()))
p1, p2 = 0, 0
P[0] = 1
S = 0
for i in range(1, n + 1):
S += arr[i - 1]
if P[S % n]:
p1 = P[S % n]
p2 = i + 1
P[S % n] = i + 1
if not p2:
print(-1)
else:
print(p2 - p1)
print(*[i for i in range(p1, p2)])
for i in range(1, n + 1):
P[i] = 0
|
IMPORT ASSIGN VAR BIN_OP LIST NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR VAR BIN_OP VAR NUMBER IF VAR BIN_OP VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR BIN_OP VAR NUMBER IF VAR EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
t = int(input())
while t != 0:
t -= 1
n = int(input())
a = [int(i) for i in input().split()]
cumm_sum = []
curr_sum = 0
for i in a:
curr_sum += i
cumm_sum.append((curr_sum + n) % n)
index_arr = [[] for i in range(n)]
for i in range(n):
index_arr[cumm_sum[i]].append(i)
if len(index_arr[0]) >= 1:
print(index_arr[0][0] + 1)
for i in range(index_arr[0][0] + 1):
print(i + 1, end=" ")
else:
for i in range(1, n):
if len(index_arr[i]) > 1:
st_idx = index_arr[i][0]
end_idx = index_arr[i][1]
size = end_idx - st_idx
print(size)
for j in range(st_idx + 1, end_idx + 1):
print(j + 1, end=" ")
break
print()
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR NUMBER FOR VAR VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR VAR ASSIGN VAR LIST VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR IF FUNC_CALL VAR VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER STRING FOR VAR FUNC_CALL VAR NUMBER VAR IF FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR VAR VAR NUMBER ASSIGN VAR VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER STRING EXPR FUNC_CALL VAR
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
_map = {(0): 0}
_sum = 0
for i in range(len(arr)):
_sum += arr[i]
r = _sum % n
if r in _map:
print(i - _map[r] + 1)
print(*range(_map[r] + 1, i + 1 + 1), sep=" ")
break
else:
_map[r] = i + 1
else:
print(-1)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR DICT NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER BIN_OP BIN_OP VAR NUMBER NUMBER STRING ASSIGN VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR NUMBER
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
def getModulo(a, n):
if a < 0:
return -a % n
else:
return a % n
for _ in range(int(input())):
n = int(input())
arr = [int(c) for c in input().split()]
p = []
s = 0
for i in arr:
s += i
p.append(getModulo(s, n))
dic = {(0): -1}
for i in range(len(p)):
if p[i] not in dic:
dic[p[i]] = i
else:
ans = range(dic[p[i]] + 1, i + 1)
break
print(len(ans))
print(*[(i + 1) for i in ans])
|
FUNC_DEF IF VAR NUMBER RETURN BIN_OP VAR VAR RETURN BIN_OP VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR NUMBER FOR VAR VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR ASSIGN VAR DICT NUMBER NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR VAR VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
for _ in range(int(input())):
n, s, d = int(input()), 0, {}
for i, j in enumerate(map(int, input().split())):
s = (s + j) % n
if s == 0:
print(i + 1)
print(*range(1, i + 2))
break
elif s in d:
print(i - d[s])
print(*range(d[s] + 2, i + 2))
break
d[s] = i
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER DICT FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR VAR
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
for _ in range(int(input())):
n = int(input())
array = list(map(int, input().split()))
ids = [(-1) for x in range(0, n, 1)]
sum = 0
exit = False
for i in range(len(array)):
sum = sum + array[i]
r = sum % n
if r == 0:
print(i + 1)
l = [(x + 1) for x in range(i, -1, -1)]
print(*l)
exit = True
break
elif ids[r] != -1:
print(i - ids[r])
l = [(x + 1) for x in range(i, ids[r], -1)]
print(*reversed(l))
exit = True
break
ids[r] = i
if exit == False:
print(-1)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER IF VAR VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
for i in range(int(input())):
n = int(input())
arr = [int(k) for k in input().split()]
mem = [(-1) for j in range(n)]
mem[0] = 0
sum = 0
for l in range(1, n + 1):
sum = sum + arr[l - 1]
sum %= n
if mem[sum] == -1:
mem[sum] = l
else:
print(l - mem[sum])
for m in range(mem[sum], l):
print(m + 1, end=" ")
print("\n")
break
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR BIN_OP VAR NUMBER VAR VAR IF VAR VAR NUMBER ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR FOR VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER STRING EXPR FUNC_CALL VAR STRING
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
t = int(input())
for _ in range(t):
N = int(input())
array = list(map(int, input().split()))
sumx = 0
sumxIndex = {}
for i in range(0, N):
sumx = (sumx + array[i]) % N
if sumx == 0:
left = 0
right = i
break
if sumx in sumxIndex.keys():
left = sumxIndex[sumx] + 1
right = i
break
sumxIndex[sumx] = i
print(right - left + 1)
for index in range(left, right + 1):
print(index + 1, end=" ")
print()
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR DICT FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR VAR IF VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR IF VAR FUNC_CALL VAR ASSIGN VAR BIN_OP VAR VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER STRING EXPR FUNC_CALL VAR
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
for _ in range(int(input())):
n = int(input())
ar = list(map(int, input().split()))
s = 0
ans = {}
f = 1
for i in range(n):
s += ar[i]
p = s % n
if p == 0:
print(i + 1)
for j in range(1, i + 2):
print(j, end=" ")
print()
break
elif p not in ans:
ans[p] = i
else:
print(i - ans[p])
for j in range(ans[p] + 2, i + 2):
print(j, end=" ")
print()
f = 0
break
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR DICT ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR STRING EXPR FUNC_CALL VAR IF VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR NUMBER
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
def solve():
t = int(input())
for i in range(t):
n = int(input())
arr = list(map(int, input().split()))
if arr[0] % n == 0:
print(1)
print(1)
continue
freq = []
for j in range(n):
freq.append([])
freq[j].append(0)
freq[0][0] = 1
freq[0].append(-1)
cum_sum = 0
for j in range(n):
cum_sum = (cum_sum + arr[j] % n) % n
freq[cum_sum][0] += 1
freq[cum_sum].append(j)
for j in range(len(freq)):
if freq[j][0] >= 2:
print(freq[j][2] - freq[j][1])
for k in range(freq[j][1] + 1, freq[j][2] + 1):
print(k + 1, end=" ")
break
solve()
|
FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF BIN_OP VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR LIST EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR VAR VAR VAR VAR VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR NUMBER VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER NUMBER BIN_OP VAR VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER STRING EXPR FUNC_CALL VAR
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
import sys
data = sys.stdin.read().split()
data.reverse()
def read():
return int(data.pop())
def readStr():
return data.pop()
T = read()
for test in range(T):
n = read()
A = [0] + [read() for i in range(n)]
F = [0] + [(-1) for i in range(n - 1)]
for i in range(1, n + 1):
A[i] = (A[i - 1] + A[i]) % n
if F[A[i]] == -1:
F[A[i]] = i
else:
ans = [str(j) for j in range(F[A[i]] + 1, i + 1)]
break
print(len(ans))
print("\n".join(ans))
|
IMPORT ASSIGN VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR VAR VAR IF VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR BIN_OP VAR VAR VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL STRING VAR
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
def sol():
n = int(input())
a = list(map(int, input().split()))
pre = [0] * n
pre[0] = a[0]
for i in range(1, n):
pre[i] = pre[i - 1] + a[i]
a = [(i % n) for i in pre]
hsh = {}
ans = []
ans1 = []
for i in range(n):
if a[i] == 0:
for j in range(i + 1):
ans1.append(j + 1)
break
elif hsh.get(a[i]) == None:
hsh[a[i]] = i
elif hsh.get(a[i]) != None:
for k in range(hsh[a[i]] + 1, i + 1):
ans.append(k + 1)
break
if ans:
print(len(ans))
print(*ans)
else:
print(len(ans1))
print(*ans1)
def main():
for _ in range(int(input())):
sol()
main()
|
FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR DICT ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER IF FUNC_CALL VAR VAR VAR NONE ASSIGN VAR VAR VAR VAR IF FUNC_CALL VAR VAR VAR NONE FOR VAR FUNC_CALL VAR BIN_OP VAR VAR VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
t = int(input())
for _ in range(t):
n = int(input())
l = list(map(int, input().split()))
ans = []
ps = 0
L = []
d = {}
c = 0
for i in range(n):
ps += l[i]
if ps % n == 0:
print(i + 1)
ans = range(1, i + 2)
c = 1
break
try:
m = d[ps % n][0]
print(i + 1 - (m + 1))
ans = range(m + 2, i + 2)
c = 1
break
except:
d[ps % n] = [i]
a = map(str, ans)
print(" ".join(a))
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR NUMBER ASSIGN VAR LIST ASSIGN VAR DICT ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR VAR LIST VAR ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL STRING VAR
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
t = int(input())
for _ in range(t):
n = int(input())
l = [int(i) for i in input().strip().split()]
curr = 0
d = {}
for i in range(n):
curr += l[i]
t = curr % n
if t == 0:
print(i + 1)
print(*[j for j in range(1, i + 2)])
break
elif t in d:
st = d[t]
le = i - st
print(le)
print(*[j for j in range(st + 2, st + le + 2)])
break
else:
d[t] = i
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR DICT FOR VAR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR VAR VAR
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
t = int(input())
for case in range(t):
n = int(input())
nos = [int(x) for x in input().split()]
copy = nos[:]
nos[0] = copy[0] % n
if nos[0] == 0:
print(1)
print(1)
continue
flag = 0
for i in range(1, n):
nos[i] = nos[i - 1] + copy[i]
nos[i] = nos[i] % n
if nos[i] == 0:
print(i + 1)
print(*[(x + 1) for x in range(i + 1)])
flag = 1
break
if flag == 1:
continue
flag = 0
index = [x for x in range(n)]
temp = [x for _, x in sorted(zip(nos, index))]
for i in range(n - 1):
if nos[temp[i]] == nos[temp[i + 1]]:
a = min(temp[i + 1], temp[i])
b = max(temp[i + 1], temp[i])
print(b - a)
print(*[(x + 1) for x in range(a + 1, b + 1)])
break
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR ASSIGN VAR NUMBER BIN_OP VAR NUMBER VAR IF VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR IF VAR VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
try:
def find():
n = int(input())
dictk = {(0): -1}
sumk = 0
nums = list(map(int, input().split()))
for i in range(n):
k = nums[i]
if k % n == 0:
print(1)
print(i + 1)
return
sumk = (sumk + k) % n
if sumk in dictk:
print(i - dictk[sumk])
print(*list(range(dictk[sumk] + 2, i + 2)))
return
dictk[sumk] = i
t = int(input())
for _ in range(t):
find()
except:
pass
|
FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR DICT NUMBER NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER RETURN ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER BIN_OP VAR NUMBER RETURN ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
d = {}
s = 0
d[0] = 0
f = 0
for i in range(1, n + 1):
s += a[i - 1]
s = s % n
if s not in d:
d[s] = i
else:
f = 1
print(i - d[s])
for j in range(d[s], i):
print(j + 1, end=" ")
print()
break
if f == 0:
print(-1)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR DICT ASSIGN VAR NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR IF VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR FOR VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER STRING EXPR FUNC_CALL VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
from sys import stdin
t = int(stdin.readline())
for case in range(t):
flag = 0
n = int(stdin.readline())
n_arr = [int(x) for x in stdin.readline().split()]
n_sum = [(-1) for x in range(n)]
n_rem = [(-1) for x in range(n)]
n_rem_arr = [(-1) for x in range(n)]
n_sum[0] = n_arr[0]
n_rem[0] = n_arr[0] % n
for i in range(1, n):
n_sum[i] = n_sum[i - 1] + n_arr[i]
n_rem[i] = n_sum[i] % n
diff_rl = 1000000
if n == 1:
print(1)
print(0)
continue
for i in range(n):
if n_arr[i] % n == 0:
print(1)
print(i + 1)
flag = 1
break
if flag == 1:
continue
for i in range(n):
if n_rem[i] == 0:
min_r = i
min_l = 0
diff_rl = min_r - min_l + 1
break
for i in range(n):
temp = n_rem[i]
if n_rem_arr[temp] == -1:
n_rem_arr[temp] = i
elif i - n_rem_arr[temp] < diff_rl:
min_r = i
min_l = n_rem_arr[temp]
diff_rl = min_r - min_l
min_l += 1
n_rem_arr[temp] = i
print(diff_rl)
for i in range(min_l, min_r + 1):
print(i + 1, end=" ")
print()
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR ASSIGN VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF BIN_OP VAR VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER ASSIGN VAR VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR IF VAR VAR NUMBER ASSIGN VAR VAR VAR IF BIN_OP VAR VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR NUMBER ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER STRING EXPR FUNC_CALL VAR
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
T = int(input())
for _ in range(T):
N = int(input())
A = list(map(int, input().strip().split(" ")))
N = len(A)
B = [(i + 1) for i in range(len(A))]
red = [(0) for i in range(len(A))]
post = {}
temp = 0
L = 0
R = N - 1
for i in range(len(A)):
temp += A[i]
temp %= N
if temp == 0:
L = 0
R = i
break
if red[temp] == 0:
post[temp] = i
red[temp] = 1
else:
L = post[temp] + 1
R = i
break
num = R - L + 1
print(num)
print(*B[L : R + 1])
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR DICT ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR IF VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR IF VAR VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR NUMBER ASSIGN VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
t = int(input())
while t > 0:
n = int(input())
a = list(map(int, input().split()))
d = {}
d[0] = 0
s = 0
for i in range(1, n + 1):
s += a[i - 1]
s %= n
if s not in d:
d[s] = i
else:
print(i - d[s])
for j in range(d[s], i):
print(j + 1, end=" ")
print()
break
t -= 1
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR DICT ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR VAR BIN_OP VAR NUMBER VAR VAR IF VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR FOR VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER STRING EXPR FUNC_CALL VAR VAR NUMBER
|
Read problems statements in Mandarin Chinese and Russian.
You are given a multiset of N integers. Please find such a nonempty subset of it that the sum of the subset's elements is divisible by N. Otherwise, state that this subset doesn't exist.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test consists of a single integer N - the size of the multiset.
The second line of each test contains N single space separated integers - the multiset's elements.
------ Output ------
For each test case output:
-1 if the required subset doesn't exist
If the required subset exists, output two lines. Output the size of the subset on the first line and output the list of indices of the multiset's element that form the required subset. Of course, any number can be taken in the subset no more than once.
If there are several such subsets, you can output any.
------ Constraints ------
$1 ≤ The sum of N over all the test cases ≤ 10^{5}$
$Each element of the multiset is a positive integer, not exceeding 10^{9}.$
$1 ≤ N ≤ 15 : 37 points. $
$1 ≤ N ≤ 1000 : 24 points.$
$1 ≤ N ≤ 10^{5} : 39 points. $
------ Example ------
Input:
1
3
4 6 10
Output:
1
2
------ Explanation ------
We can pick {6} as the subset, then its sum is 6 and this is divisible by 3 - the size of the initial multiset.
|
for t in range(int(input())):
n = int(input())
a = [int(i) for i in input().split()]
store = {(0): 0}
s = 0
for i in range(n):
s = (s + a[i]) % n
if s in store:
ans = range(store[s] + 1, i + 2)
break
store[s] = i + 1
print(len(ans))
print(*ans)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR DICT NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR VAR IF VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.