description stringlengths 171 4k | code stringlengths 94 3.98k | normalized_code stringlengths 57 4.99k |
|---|---|---|
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
coords = n * [-1]
coordsy = list()
coordsz = list()
for i in range(n):
coords[i] = [int(i) for i in input().split()] + [i]
coords.sort()
i = 0
while i < len(coords) - 1:
if coords[i][:2] == coords[i + 1][:2]:
print(coords[i][3] + 1, coords[i + 1][3] + 1)
i += 1
else:
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP VAR LIST NUMBER ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR BIN_OP FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR LIST VAR EXPR FUNC_CALL VAR ASSIGN VAR NUMBER WHILE VAR BIN_OP FUNC_CALL VAR VAR NUMBER IF VAR VAR NUMB... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
arr = []
for _ in range(n):
a, b, c = map(int, input().split())
arr.append([a, b, c] + [_ + 1])
arr.sort()
ans = []
for i in range(2, -1, -1):
st = []
for x in arr:
if st and all(st[-1][itr] <= x[itr] for itr in range(i + 1)):
ans.append((st.pop()[-1], x[-1]))
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR BIN_OP LIST VAR VAR VAR LIST BIN_OP VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR LIST FOR VAR VAR IF VAR... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | def solve(n, points):
for i in range(n):
points[i].append(i + 1)
points.sort()
points += [(float("inf"),) * 3]
rem = []
i = 0
while i < n:
if points[i][:2] == points[i + 1][:2]:
print(points[i][3], points[i + 1][3])
i += 2
else:
rem.app... | FUNC_DEF FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR LIST BIN_OP FUNC_CALL VAR STRING NUMBER ASSIGN VAR LIST ASSIGN VAR NUMBER WHILE VAR VAR IF VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER EXPR FUNC_CA... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
lol = []
d = dict()
d1 = dict()
for i in range(n):
x, y, z = map(int, input().split())
lol.append([x, y, z, i + 1])
lol.sort()
for ii in range(n):
x = lol[ii][0]
y = lol[ii][1]
z = lol[ii][2]
i = lol[ii][3] - 1
try:
d[str([x, y])].append(i + 1)
except:
d[... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR LIST VAR VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR NUMBER ASS... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | import sys
def calcManhattan(i, j, coords):
if j == -1:
return inf
x1, y1, z1 = coords[i]
x2, y2, z2 = coords[j]
return abs(x1 - x2) + abs(y1 - y2) + abs(z1 - z2)
def main():
n = int(input())
coords = []
for i in range(1, n + 1):
x, y, z = readIntArr()
coords.appe... | IMPORT FUNC_DEF IF VAR NUMBER RETURN VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR RETURN BIN_OP BIN_OP FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR BIN_OP VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | arr = [tuple(map(int, input().split())) for _ in range(int(input()))]
arr = list(enumerate(arr, 1))
while len(arr):
p = arr[0]
q = sorted(
arr,
key=lambda i: abs(p[1][0] - i[1][0])
+ abs(p[1][1] - i[1][1])
+ abs(p[1][2] - i[1][2]),
)[1]
print(p[0], q[0])
arr.remove(p)... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER WHILE FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER NUMBER FUNC_CALL V... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
array = []
dic = {}
for x in range(n):
a, b, c = list(map(int, input().split()))
array.append([a, b, c])
flag = 5
index = 5 - 5
for it in array:
dic[str(it)] = index
index += 1
while True:
lenn = len(array)
if lenn == 2:
break
for x in range(lenn):
flag =... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR DICT FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR LIST VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP NUMBER NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR NUMBER WHILE ... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | import sys
input = sys.stdin.readline
n = int(input())
it = set()
for _ in range(n):
a, b, c = map(int, input().split())
it.add((a, b, c, _))
for i in range(n // 2):
aa = it.pop()
b = it.pop()
mi = b[:]
it.add(b)
for j in it:
st = True
for k in range(3):
if min(a... | IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR VAR EXPR FU... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
coords = n * [-1]
for i in range(n):
coords[i] = [int(i) for i in input().split()] + [i]
coords.sort()
i = 0
while i < len(coords) - 1:
if coords[i][:2] == coords[i + 1][:2]:
print(coords[i][3] + 1, coords[i + 1][3] + 1)
coords.pop(i)
coords.pop(i)
i -= 1
i +... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP VAR LIST NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR BIN_OP FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR LIST VAR EXPR FUNC_CALL VAR ASSIGN VAR NUMBER WHILE VAR BIN_OP FUNC_CALL VAR VAR NUMBER IF VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
arr = []
for _ in range(n):
arr.append(list(map(int, input().split())) + [_ + 1])
arr.sort(key=lambda x: (x[0], x[1], x[2]))
res = []
def valid(pt1, pt2, axis):
flag = 1
for k in range(axis + 1):
if pt1[k] > pt2[k]:
flag = 0
break
return flag
for axis... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR LIST BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR LIST FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
m = []
for _ in range(n):
m.append(tuple(map(int, input().split())))
m = list(enumerate(m))
while len(m) > 0:
p = m[0]
x, y, z = p[1]
q = sorted(m, key=lambda i: abs(i[1][0] - x) + abs(i[1][1] - y) + abs(i[1][2] - z))[
1
]
print(p[0] + 1, q[0] + 1)
m.remove(q)
de... | 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 ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR WHILE FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP BI... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
l = [list(map(int, input().split())) for i in range(n)]
a = [[l[i], i + 1] for i in range(n)]
used = [0] * (n + 1)
a.sort()
d = {}
for i in a:
d[i[0][0]] = []
for i in a:
d[i[0][0]].append([i[0][1], i[0][2], i[1]])
for x in d:
l = d[x]
b = {}
for i in l:
b[i[0]] = []
for... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR LIST VAR VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR DICT FOR VAR VAR ASSIGN VAR VAR NUMBER NUMBER LIST... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | import sys
n = int(input())
d = [tuple([int(i) for i in sys.stdin.readline().split()]) for j in range(n)]
index = {}
for i in range(n):
index[d[i]] = i + 1
d.sort()
untaken = []
dic = {}
i = 0
while i < n:
first = d[i][0]
if first not in dic:
dic[first] = []
dic[first].append((d[i][1], d[i][2])... | IMPORT 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 ASSIGN VAR DICT FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR DICT ASSIGN VAR NUMBER WHILE VAR VAR ASSIGN VAR VAR VAR ... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | def solve_z(points):
cur = None
d = {}
for p in points:
if p[0] not in d:
d[p[0]] = []
d[p[0]].append(p)
for k in d:
d[k] = sorted(d[k], key=lambda x: x[1])
for k in sorted(d.keys()):
n = len(d[k])
for i in range(0, n, 2):
if i + 1 == n... | FUNC_DEF ASSIGN VAR NONE ASSIGN VAR DICT FOR VAR VAR IF VAR NUMBER VAR ASSIGN VAR VAR NUMBER LIST EXPR FUNC_CALL VAR VAR NUMBER VAR FOR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR NUMBER IF BIN_OP VAR NUMBE... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | def solve(points, ans, coords, x):
arr = []
curr = []
y = points[0][0]
for p in points:
if p[0] == y:
curr.append((y, p[1], p[2]))
else:
arr.append(curr)
y = p[0]
curr = [(y, p[1], p[2])]
arr.append(curr)
arr1 = []
for i in arr:... | FUNC_DEF ASSIGN VAR LIST ASSIGN VAR LIST ASSIGN VAR VAR NUMBER NUMBER FOR VAR VAR IF VAR NUMBER VAR EXPR FUNC_CALL VAR VAR VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR LIST VAR VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR LIST FOR VAR VAR WHILE FUNC_CALL VAR VAR NUMBER EXPR F... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | class HiIAmClass:
def __init__(self, p, x, y, z):
self.p = p
self.x = x
self.y = y
self.z = z
def __lt__(self, other):
return (self.x, self.y, self.z) < (other.x, other.y, other.z)
n = int(input())
l = []
for i in range(1, n + 1):
x, y, z = [int(x) for x in input(... | CLASS_DEF FUNC_DEF ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR FUNC_DEF RETURN VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR V... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | import sys
input = sys.stdin.readline
n = int(input())
P = [(list(map(int, input().split())) + [i + 1]) for i in range(n)]
P.sort(reverse=True)
P2 = []
while P:
x, y, z, w = P.pop()
if len(P) > 0 and x == P[-1][0] and y == P[-1][1]:
x2, y2, z2, w2 = P.pop()
print(w, w2)
else:
P2.app... | IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR LIST BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR NUMBER ASSIGN VAR LIST WHILE VAR ASSIGN VAR VAR VAR VAR FUNC_CALL VAR IF FUNC_CALL VAR VAR NUMBER VAR VAR NUMBER NUMBER V... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | import sys
n = -1
data = []
for line in sys.stdin:
if n == -1:
n = int(line)
continue
data.append(tuple([int(i) for i in line.split()]))
if len(data) == n:
break
data = list(zip(data, range(1, n + 1)))
data.sort()
data2 = []
removedLast = False
for i in range(n):
if removedLast:... | IMPORT ASSIGN VAR NUMBER ASSIGN VAR LIST FOR VAR VAR IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR IF FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR NU... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
coors = []
for i in range(n):
coors.append(list(map(int, input().split())) + [i + 1])
coors = sorted(coors, key=lambda x: (x[0], x[1], x[2]))
left = []
def oneD(co, remain):
if len(co) % 2 == 0:
for i in range(0, len(co), 2):
print(co[i][3], co[i + 1][3])
else:
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR LIST BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR LIST FUNC_DEF IF BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER FOR V... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
p = [(list(map(int, input().split())) + [i]) for i in range(n)] + [
[10**9, 10**9, 10**9]
]
p.sort(key=lambda x: tuple(x[:-1]))
rem = []
i = 0
while i < n:
if p[i][:2] == p[i + 1][:2]:
print(p[i][-1] + 1, p[i + 1][-1] + 1)
i += 2
else:
rem.append(p[i])
i += 1... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR LIST VAR VAR FUNC_CALL VAR VAR LIST LIST BIN_OP NUMBER NUMBER BIN_OP NUMBER NUMBER BIN_OP NUMBER NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR LIST ASSIGN VAR NUMBER WHILE VAR VAR IF V... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | def solve(n, p):
p = sorted(p, key=lambda x: (x[0], x[1], x[2]))
p.append([10**20, 10**20, 10**20, 10**20])
c = 1
pn = []
for i in range(1, len(p)):
if p[i][0] == p[i - 1][0]:
c += 1
else:
if c >= 2:
s = solve_2d(p[i - c : i])
i... | FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR LIST BIN_OP NUMBER NUMBER BIN_OP NUMBER NUMBER BIN_OP NUMBER NUMBER BIN_OP NUMBER NUMBER ASSIGN VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR IF VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER IF... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | import sys
input = sys.stdin.readline
def d(le):
for i in range(0, len(le), 2):
print(le[i][3], le[i + 1][3])
def dd(it):
global do
tt = {}
ddd = []
it.sort(key=lambda x: x[1])
l = list(set([i[1] for i in it]))
l.sort()
for i in l:
tt[i] = []
for i in it:
... | IMPORT ASSIGN VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER FUNC_DEF ASSIGN VAR DICT ASSIGN VAR LIST EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER VAR VAR EXPR FUNC_CALL VAR FOR VAR VAR ASSIGN VAR V... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
dot = []
for i in range(n):
x, y, z = map(int, input().split())
dot.append([x, y, z, i + 1])
dot.sort(key=lambda x: (x[2], x[0], x[1]))
m = {}
for i in range(n):
if dot[i][2] not in m:
m[dot[i][2]] = [dot[i]]
else:
m[dot[i][2]].append(dot[i])
new_m = []
for key in m:
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR LIST VAR VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR DICT FOR VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER VAR ASSIGN V... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | import sys
input = sys.stdin.readline
write = sys.stdout.write
n = int(input())
point = []
for i in range(n):
point.append(list(map(int, input().split())) + [i + 1])
for _ in range(n // 2):
ax, ay, az, a = point.pop()
temp = 10**18
next = -1
for i in range(len(point)):
bx, by, bz, _ = point... | IMPORT ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR LIST BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR FUNC_CALL VAR ASSIGN VAR BIN_OP NU... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | def solve(n, points):
points = [(p + (i,)) for i, p in enumerate(points, 1)]
points += [(10**9,) * 3]
points.sort()
ans = []
rem = []
i = 0
while i < n:
if points[i][:2] == points[i + 1][:2]:
ans.append((points[i][-1], points[i + 1][-1]))
i += 2
else:
... | FUNC_DEF ASSIGN VAR BIN_OP VAR VAR VAR VAR FUNC_CALL VAR VAR NUMBER VAR LIST BIN_OP BIN_OP NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR LIST ASSIGN VAR NUMBER WHILE VAR VAR IF VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER EXPR... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
points = []
s = set()
def dist(a, b):
return abs(a[0] - b[0]) + abs(a[1] - b[1]) + abs(a[2] - b[2])
for i in range(n):
arr = map(int, input().split())
points.append(list(arr))
s.add(i)
dis = {}
for i in range(n):
if i in s:
max = 1e18
x = -1
for j in rang... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR FUNC_CALL VAR FUNC_DEF RETURN BIN_OP BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EX... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | import sys
input = sys.stdin.readline
n = int(input())
p = [[*map(int, input().split())] for i in range(n)]
a = p[0]
b = p[1]
pt1 = 0
pt2 = 1
d = dict()
while pt1 < n and pt2 < n:
a = p[pt1]
b = p[pt2]
yy = pt2 + 1
for i in range(yy, n):
if (
d.get(i, -1) == -1
and min(a... | IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR WHILE VAR VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR BIN... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
pts = {}
for i in range(1, n + 1):
x, y, z = map(int, input().split())
pts[i] = x, y, z
ans = []
x, y, z = pts[1]
pair = [1]
del pts[1]
while pts:
mn = float("inf")
for i in pts:
x1, y1, z1 = pts[i]
dist = abs(x - x1) + abs(y - y1) + abs(z - z1)
if dist < mn:
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR DICT FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR LIST ASSIGN VAR VAR VAR VAR NUMBER ASSIGN VAR LIST NUMBER VAR NUMBER WHILE VAR ASSIGN VAR FUNC_CALL VAR STRING FOR VAR ... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | from sys import stdin
input = stdin.readline
R = lambda: list(map(int, input().split()))
(n,) = R()
a = []
delete = n * [0]
for i in range(n):
a.append(R())
def test(x1, x2, x):
if min(x1, x2) <= x and x <= max(x1, x2):
return 1
return 0
for i in range(n // 2):
x1, y1, z1 = "0", "0", "0"
... | ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR BIN_OP VAR LIST NUMBER FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF IF FUNC_CALL VAR VAR VAR VAR VAR FUNC_CALL VAR VAR VAR RETURN NUMBER RETURN NUMBER FOR VAR FUNC... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | from sys import stdin, stdout
n = int(stdin.readline())
l = []
for i in range(n):
x = list(map(int, stdin.readline().split()))
l.append([x, i + 1])
l.sort()
deleted = [0] * n
for i in range(n - 1):
if deleted[i]:
continue
if l[i][0][0] == l[i + 1][0][0] and l[i][0][1] == l[i + 1][0][1]:
... | 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 LIST VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR IF VAR VAR NUMBER NUMB... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
arr = []
ans = []
for _ in range(n):
x, y, z = map(int, input().split())
arr.append([x, y, z])
visited = [False] * n
for i in range(n):
distance = 10**10
if visited[i] == False:
for j in range(i + 1, n):
if not visited[i] and not visited[j] and i != j:
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR LIST VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP NUMBER NUMBER IF VAR VAR NUMBER FOR VAR FUNC_CAL... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
pts = []
for i in range(n):
a, b, c = map(int, input().split())
pts.append((a, b, c, i))
dicter = [(float("inf"), 0)] * n
was2 = [0] * n
for el1 in pts:
if not was2[el1[3]]:
for el2 in pts:
if not was2[el2[3]]:
if el1[3] != el2[3]:
ku ... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP LIST FUNC_CALL VAR STRING NUMBER VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR VAR IF VAR VAR NUMBER FOR VAR VAR IF VAR VAR N... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | import sys
input = sys.stdin.readline
def solve1d(a):
a.sort()
for i in range(0, len(a) - 1, 2):
print(a[i][-1] + 1, a[i + 1][-1] + 1)
if len(a) % 2:
return a[-1]
return False
def solve2d(start, end):
d = {}
for i in range(start, end + 1):
if coor[i][1] not in d:
... | IMPORT ASSIGN VAR VAR FUNC_DEF EXPR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR NUMBER NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER NUMBER IF BIN_OP FUNC_CALL VAR VAR NUMBER RETURN VAR NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR DICT FOR VAR FUNC_CALL V... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
sentinel = [(10**9, 10**9, 10**9)]
points = (
sorted(tuple(map(int, input().split())) + (i,) for i in range(1, n + 1)) + sentinel
)
ans = []
rem = []
i = 0
while i < n:
if points[i][:2] == points[i + 1][:2]:
ans.append(f"{points[i][-1]} {points[i + 1][-1]}")
i += 2
else:
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST BIN_OP NUMBER NUMBER BIN_OP NUMBER NUMBER BIN_OP NUMBER NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR VAR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR ASSIGN VAR LIST ASSIGN VAR LIST ASSIGN VAR NUMBER WHILE ... |
This is an easier version of the problem. In this version, $n \le 2000$.
There are $n$ distinct points in three-dimensional space numbered from $1$ to $n$. The $i$-th point has coordinates $(x_i, y_i, z_i)$. The number of points $n$ is even.
You'd like to remove all $n$ points using a sequence of $\frac{n}{2}$ snaps.... | n = int(input())
coords = [list(map(int, input().split())) for i in range(n)]
indexes = list(range(1, n + 1))
coords, indexes = list(map(list, zip(*sorted(zip(coords, indexes)))))
result = []
while len(coords) > 0:
a = coords[0]
b = coords[1]
aind = 0
bind = 1
for i in range(len(coords)):
if... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR ASSIGN VAR LIST WHILE FUNC_CALL... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | t = int(input())
for m in range(t):
n = int(input())
arr = list(map(int, input().split()))
left = 0
right = 0
maxdif = 0
dif = 0
while right < n:
if arr[left] >= arr[right]:
dif = arr[left] - arr[right]
if dif > maxdif:
maxdif = dif
els... | 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 WHILE VAR VAR IF VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR IF VAR VAR... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | from sys import stderr, stdin
def rl():
return [int(w) for w in stdin.readline().split()]
(t,) = rl()
for _ in range(t):
(n,) = rl()
a = rl()
m = a[n - 1]
d = 0
for i in range(n - 2, -1, -1):
if a[i] < m:
m = a[i]
elif a[i] > m + d:
d = a[i] - m
r ... | FUNC_DEF RETURN FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR VAR ASSIGN VAR VAR VAR IF VAR VAR BIN_OP ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | i, tmp = 1, 1
x = [1]
while tmp < 1000000000:
tmp *= 2
x.append(x[i - 1] + tmp)
i += 1
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
ans = 0
if n > 1:
max_diff = 0
for i in range(1, n):
if a[i - 1] > a[i]:
max_d... | ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR LIST NUMBER WHILE VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR BIN_OP VAR NUMBER VAR 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 ASSIGN VAR NUMBER IF ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | for _ in range(int(input())):
n = int(input())
a = [int(i) for i in input().split()]
maxx = a[0]
val = []
for i in a[1:]:
if maxx > i:
val.append(maxx - i)
else:
maxx = i
if val:
x = max(val)
i = 0
while x > 0:
x -= 2**i... | 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 VAR NUMBER ASSIGN VAR LIST FOR VAR VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR ASSIGN VAR VAR IF VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER WHI... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | for _ in range(int(input())):
n = int(input())
a = [int(i) for i in input().split()]
m = a[0]
p = 0
for i in range(1, n):
m = max(m, a[i])
p = max(p, m - a[i])
c = 0
while 2**c <= p:
c += 1
print(c) | 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 VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR VAR ASSIGN VAR NUMBE... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | test_cases = int(input())
second = []
for i in range(int(test_cases)):
length = input()
array = [int(idx) for idx in input().split(" ")]
sec = 0
idx = 0
for i in range(int(length) - 1):
if array[i] > array[i + 1]:
diff = array[i] - array[i + 1]
array[i + 1] += diff
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR BI... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | import sys
sys.setrecursionlimit(10**6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II():
return int(sys.stdin.readline())
def MI():
return map(int, sys.stdin.readline().split())
def LI():
return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number):
return [... | IMPORT EXPR FUNC_CALL VAR BIN_OP NUMBER NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR STRING FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN FUNC... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def powered(n, x):
cur = x[0]
dif = 0
for v in x:
if v > cur:
cur = v
else:
dif = max(dif, cur - v)
res = 0
while dif:
res += 1
dif //= 2
return res
t = int(input())
for i in range(t):
n = int(input())
x = list(map(int, input().sp... | FUNC_DEF ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR NUMBER WHILE 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 FUNC_CALL VAR... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | for T in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
Ret = 0
for i in range(n - 1):
if a[i] > a[i + 1]:
Bin = bin(a[i] - a[i + 1])[2:]
Ret = max(Ret, len(Bin) - Bin.index("1"))
a[i + 1] = a[i]
print(Ret) | 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 FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER NUMBER ASSI... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | import sys
input = sys.stdin.readline
t = int(input())
out = []
for _ in range(t):
n = int(input())
l = list(map(int, input().split()))
big = l[0]
need = 0
for v in l:
if v < big:
need = max(need, big - v)
else:
big = v
curr = 0
p = 0
while p < ne... | IMPORT ASSIGN 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 ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSI... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | for i in range(int(input())):
input()
max_num = float("-inf")
max_diff = 0
for j in map(int, input().split()):
if j > max_num:
max_num = j
else:
max_diff = max(max_diff, max_num - j)
if max_diff == 0:
print(0)
else:
print(len(bin(max_diff))... | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR F... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | z = int(input())
while z:
z -= 1
n = int(input())
a = list(map(int, input().strip().split(" ")))
t = 0
last = a[0]
for i in range(1, n):
if a[i] >= last:
last = a[i]
else:
d = last - a[i]
x = len(bin(d)[2:])
if x > t:
... | 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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def find_T(n):
a = bin(n)
m = len(a)
for i in range(m):
if a[i] == "1":
return m - i
def find_ans(n):
s = list(map(int, input().split()))
b = s[0]
ans = 0
for i in range(1, n):
if s[i] >= b:
b = s[i]
else:
ans = max(ans, find_T(b ... | FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR STRING RETURN BIN_OP VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR VAR ASSIGN VAR VAR VAR ASSI... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | for _ in " " * int(input()):
a = int(input())
b = list(map(int, input().split()))
s = j = 0
for i in range(1, a):
if b[i - 1] > b[i]:
s = max(s, b[i - 1] - b[i])
b[i] = b[i - 1]
while s:
j += 1
s //= 2
print(j) | FOR VAR BIN_OP STRING 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 VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | t = int(input())
for _ in range(0, t):
n = int(input())
Array = [i for i in map(int, input().split())]
if len(Array) == 1:
print(0)
else:
MIN = Array[n - 1]
index = n - 2
k = Array[index]
diff = k - MIN
for j in range(0, n - 2):
MIN = min(MIN, ... | 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 VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR BI... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
def solve():
N = getInt()
A = getInts()
if N == 1:
return 0
... | FUNC_DEF RETURN FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF RETURN VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR IF VAR NUMBER RETURN NUMBER ASSIG... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def next_pow(num):
b = bin(num)[2:]
if b.count("1") == 1:
return len(b) - 1
else:
return len(b) - 1
def main():
n = int(input())
arr = list(map(int, input().split()))
score = 0
m = arr[0]
for i in range(1, n):
d = arr[i] - m
if d < 0:
k = nex... | FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR NUMBER IF FUNC_CALL VAR STRING NUMBER RETURN BIN_OP FUNC_CALL VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR VAR NUMBER 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 NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUN... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | from sys import stdin, stdout
def f(a, n):
ans = 0
m = a[0]
for i in range(1, n):
if m > a[i]:
x = m - a[i]
bi = len(bin(x)) - 2
if bi > ans:
ans = bi
if m < a[i]:
m = a[i]
else:
m = a[i]
print(... | FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF VAR VAR ASSIGN VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | T = int(input())
for t in range(T):
N = int(input())
A = [int(_) for _ in input().split()]
max_so_far = A[0]
answer = 0
for i in range(1, N):
el = A[i]
max_so_far = max(max_so_far, el)
answer = max(answer, (max_so_far - el).bit_length())
print(answer) | 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 NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def maxi(a):
ind = 0
max = -(10**9)
for u in range(0, len(a)):
if a[u] > max:
max = a[u]
ind = u
return ind
t = int(input())
for k in range(0, t):
n = int(input())
a = input().split(" ")
b = []
for i in range(0, n):
a[i] = int(a[i])
for i in ... | FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR BIN_OP NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR RETURN VAR 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 FUNC_CALL VAR STRING A... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | for _ in range(int(input())):
n = int(input())
lst = [int(i) for i in input().split()]
max1 = lst[0]
max2 = 0
for i in range(1, n):
if max1 <= lst[i]:
max1 = lst[i]
elif max2 < max1 - lst[i]:
max2 = max1 - lst[i]
nd = 0
while max2 > 0:
nd += 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 VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR VAR ASSIGN VAR VAR VAR IF VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
if n == 1:
print(0)
else:
mini = 0
i = 1
mark = 0
f = 0
while i < n:
if a[i] >= a[i - 1] and f == 0:
mark = i
i += 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 VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR VAR IF VAR VAR VAR BIN_OP VAR NUMBER VAR N... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | t = int(input())
while t:
n = int(input())
a = list(map(int, input().split()))
time = 0
for i in range(1, n):
if a[i - 1] > a[i]:
dif = a[i - 1] - a[i]
ti = 0
s = 1
while a[i - 1] > a[i]:
a[i] += s
ti += 1
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE 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 FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMB... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | t = int(input())
for _ in range(t):
z = 1
n = int(input())
arr = list(map(int, input().rstrip().split(" ")))
curMax = -9999999999
maxIncrease = 0
for i in range(n):
if arr[i] > curMax:
curMax = arr[i]
else:
diff = curMax - arr[i]
if diff > maxI... | 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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR BIN_OP ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | testCases = int(input())
for i1 in range(testCases):
x = int(input())
seq = list(map(int, input().split()))
req = [0]
add_req = set([0])
for i2 in range(1, x, 1):
temp = seq[i2 - 1] - seq[i2]
if temp > 0:
seq[i2] = seq[i2 - 1]
y = "{0:b}".format(temp)
... | 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 NUMBER ASSIGN VAR FUNC_CALL VAR LIST NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR I... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | t = int(input())
for test_case in range(t):
n = int(input())
array = list(map(int, input().split()))
max_diff = 0
max_val = array[0]
for i in range(1, len(array), 1):
if array[i] < max_val:
max_diff = max(max_diff, max_val - array[i])
else:
max_val = array[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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR NUMBER IF VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | from sys import stdin
t = int(input())
for _ in range(t):
n = int(input())
l = list(map(int, stdin.readline().split()))
prev = l[0]
diff = []
for e in l:
if e < prev:
diff.append(prev - e)
else:
prev = e
if len(diff) == 0:
print(0)
else:
... | 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 ASSIGN VAR LIST FOR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR ASSIGN VAR VAR IF FUNC_CALL VAR VAR NUMBER EXPR FUNC_C... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def solve(a):
maxdiff = 0
lastmax = a[0]
for ni in range(1, len(a)):
if a[ni] > lastmax:
lastmax = a[ni]
else:
maxdiff = max(maxdiff, lastmax - a[ni])
p = 0
while maxdiff > 0:
p += 1
maxdiff //= 2
return p
t = int(input())
ans = []
for ti... | FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR VAR ASSIGN VAR NUMBER WHILE VAR NUMBER VAR NUMBER VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL V... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | for _ in range(int(input())):
n = int(input())
lst = [int(i) for i in input().split()]
result = 0
for i in range(1, n):
diff = lst[i - 1] - lst[i]
if diff > 0:
result = max(result, len(bin(diff)) - 2)
lst[i] = lst[i - 1]
print(result) | 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 FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP FUNC_CALL VAR FUNC_CALL V... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | import sys
input = sys.stdin.readline
po = [1]
for i in range(40):
po += [po[-1] * 2]
for i in range(1, 40):
po[i] += po[i - 1]
t = int(input())
for _ in range(t):
n = int(input())
arr = list(map(int, input().split()))
pre = [arr[0]]
x = [0]
for i in arr:
if pre[-1] > i:
... | IMPORT ASSIGN VAR VAR ASSIGN VAR LIST NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR LIST BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER VAR VAR VAR BIN_OP VAR 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... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
x = a[0]
d = 0
for y in a:
d = max(d, x - y)
x = max(x, y)
v = 0
while d:
v += 1
d //= 2
print(v) | 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 VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER WHILE VAR VAR NUM... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | import sys
lines = sys.stdin.readlines()
T = int(lines[0].strip())
for t in range(T):
n = int(lines[2 * t + 1].strip())
nums = list(map(int, lines[2 * t + 2].strip().split(" ")))
maxSec = 0
tmpMax = nums[0]
for i in range(1, n):
if nums[i] < tmpMax:
diff = bin(tmpMax - nums[i])[... | IMPORT ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR BIN_OP BIN_OP NUMBER VAR NUMBER STRING ASSIGN VAR NUMBER ASSIGN VAR VAR NUMBER... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | import sys
def main():
res = ""
input = sys.stdin.readline
t = int(input())
for _ in range(t):
sub_res = 0
n = int(input())
a = list(map(int, input().split()))
for i in range(1, n):
if a[i] < a[i - 1]:
k = len(bin(a[i - 1] - a[i])) - 2
... | IMPORT FUNC_DEF ASSIGN VAR STRING ASSIGN VAR VAR 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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_O... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(n - 1):
diff = a[i] - a[i + 1]
if diff <= 0:
continue
else:
ans = max(len(bin(diff)) - 2, ans)
... | IMPORT ASSIGN 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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER IF VAR NUMBER ASSIGN ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | import sys
readline = sys.stdin.readline
T = int(readline())
Ans = [None] * T
for qu in range(T):
N = int(readline())
A = list(map(int, readline().split()))
A = [(10**9 + a) for a in A]
ctr = A[0]
ans = 0
for i in range(1, N):
a = A[i]
if a >= ctr:
ctr = a
... | IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NONE 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 BIN_OP BIN_OP NUMBER NUMBER VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER FOR ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | m = int(input())
for j in range(m):
n = int(input())
a = list(map(int, input().split()))
max_ = a[0]
maxdif = 0
for x in a:
if max_ - x > maxdif:
maxdif = max_ - x
if x > max_:
max_ = x
i = 0
while maxdif > 0:
maxdif //= 2
i += 1
pr... | 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 ASSIGN VAR NUMBER FOR VAR VAR IF BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER WHILE... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | t = int(input())
for i in range(t):
n = int(input())
w = [int(k) for k in input().split()]
mx = -(10**10)
res = 0
for j in w:
res = max(res, mx - j)
mx = max(mx, j)
print(len(bin(res)[2:]) if res > 0 else 0) | 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 BIN_OP NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR V... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | t = int(input())
for tc in range(t):
n = int(input())
a = list(map(int, input().split()))
def p2(x):
for k in range(1, 100):
if 2 ** (k - 1) > x:
return k - 1
sol = 0
for i in range(1, n):
if a[i] < a[i - 1]:
x = a[i - 1] - a[i]
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 FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER NUMBER IF BIN_OP NUMBER BIN_OP VAR NUMBER VAR RETURN BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
t = 0
peak = -(10**9)
for i in a:
if i > peak:
peak = i
else:
t = max(t, (peak - i).bit_length())
print(t) | 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 BIN_OP NUMBER NUMBER FOR VAR VAR IF VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def highest_set_bit(n):
l = 0
while n > 0:
n = n >> 1
l += 1
return l
t = int(input())
while t:
n = int(input())
a = list(map(int, input().split()))
time = 0
for i in range(1, n):
if a[i - 1] > a[i]:
dif = a[i - 1] - a[i]
time = max(time, hig... | FUNC_DEF ASSIGN VAR NUMBER WHILE VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE 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 FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR BIN_OP VAR N... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | for w in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
x = a[0]
l = [0] * 33
m = -1
for i in range(33):
l[i] = pow(2, i)
for i in range(1, n):
if a[i] >= a[i - 1]:
continue
else:
diff = a[i - 1] - a[i]
fo... | 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 VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR NUMBER VAR FOR VAR FUNC_CALL ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | for _ in range(int(input())):
n = int(input())
A = list(map(int, input().split()))
a = 0
bits = [(0) for i in range(36)]
ans = 0
for i in range(1, n):
if A[i] < A[i - 1]:
a = A[i - 1] - A[i]
A[i] = A[i - 1]
j = 0
while a:
a ... | 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 NUMBER VAR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP V... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | I = input
for _ in range(int(I())):
I()
m = -1000000000.0
l = 0
for x in map(int, I().split()):
m = max(m, x)
l = max(l, m - x)
print(l and len(f"{l:b}")) | ASSIGN VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR FUNC_CALL VAR VAR STRING |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | t = int(input())
for testcase in range(t):
n = int(input())
a = [int(x) for x in input().split()]
mx = 0
for i in range(1, len(a)):
if a[i] >= a[i - 1]:
continue
diff = a[i - 1] - a[i]
mx = max(mx, len(str(bin(diff))) - 2)
a[i] = a[i - 1]
print(mx) | 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 NUMBER FUNC_CALL VAR VAR IF VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR FU... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | t = int(input())
for case in range(1, t + 1):
n = int(input())
arr = [int(x) for x in input().split(" ")]
tick = 0
prev = -2000000000.0
for a in arr:
if a > prev:
prev = a
else:
while a + 2**tick - 1 < prev:
tick += 1
print(tick) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR ASSIGN VAR VAR WHILE BIN_OP BIN_OP VAR BIN_OP NUMBER VAR NUMBER VAR VAR ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def solve(num):
ans = 0
binary = bin(num)[2:]
l = len(binary)
for i in range(l):
if binary[i] == "1":
return l - i
return 0
t = int(input())
for i in range(t):
n = int(input())
data = list(map(int, input().split()))
m = data[0]
ans = 0
for i in range(1, len(... | FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR STRING RETURN BIN_OP VAR VAR RETURN 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 F... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | import sys
def get(num):
count = 0
while num > 0:
num //= 2
count += 1
return count
t = int(sys.stdin.readline())
for _ in range(t):
n = int(sys.stdin.readline())
arr = list(map(int, sys.stdin.readline().split()))
nax = arr[0]
ans = 0
for i in range(1, n):
nax... | IMPORT FUNC_DEF ASSIGN VAR NUMBER WHILE VAR NUMBER 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 FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUM... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | T = int(input())
for test in range(T):
N = int(input())
vec = list(map(int, input().split()))
diff = []
mxm = vec[0]
for i in range(N - 1):
diff.append(mxm - vec[i + 1])
mxm = max(mxm, vec[i + 1])
Tmin = 0
for d in diff:
T = 1
if d <= 0:
continue
... | 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 VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CAL... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def min_2(n):
if n == 0:
return 0
ans = 1
x = 1
while n > x:
n -= x
ans += 1
x *= 2
return ans
for t in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
temp = -(10**9)
max_d = 0
for i in range(len(a)):
if a[i] ==... | FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR VAR VAR VAR VAR NUMBER VAR NUMBER 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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP NUMBER NUMBER ASSI... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def solve():
n = int(input())
a = list(map(int, input().split()))
c = a[0]
g = 0
for x in a:
if c < x:
c = x
else:
g = max(g, c - x)
return g.bit_length()
t = int(input())
for _ in range(t):
print(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 VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR RETURN FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR V... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | import sys
input = sys.stdin.readline
t = int(input())
for tests in range(t):
n = int(input())
A = list(map(int, input().split()))
MAX = -1 << 30
ANS = 0
for a in A:
MAX = max(MAX, a)
if a < MAX:
ANS = max(ANS, MAX - a)
if ANS == 0:
print(0)
continue
... | IMPORT ASSIGN 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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR IF VAR VAR ASSIGN VAR FUNC_CALL ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | t = int(input())
for _ in range(t):
n = int(input())
a = [int(e) for e in input().split()]
max_a = a[0]
ans = 0
for i in range(1, n):
if a[i] < max_a:
delta = max_a - a[i]
c = 0
while delta > 0:
delta = delta // 2
c = c + 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 VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR NUMBER WHILE VAR NUMBER ASSIGN... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
x = 0
for i in range(n - 1):
dx = a[i + 1] - a[i]
if dx >= 0:
continue
else:
a[i + 1] = a[i]
y = 1
cy = 0
while y <= -dx:
... | 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 FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR IF VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def to_list(s):
return list(map(lambda x: int(x), s.split(" ")))
def get_x(n, powers):
k = 0
power = powers[k]
while n >= power:
k += 1
power = powers[k]
return k
def solve(a):
b = []
b.append(a[0])
min_x = 0
powers = [(2**item) for item in range(32)]
for i in... | FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR STRING FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR VAR VAR WHILE VAR VAR VAR NUMBER ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR LIST EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP NUMBER VAR VAR FUNC_CALL VAR NUMBER FOR VAR F... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def poweredAddtn(arr):
m = arr[0]
add = 0
x = 0
for i in arr:
while m > i + add:
x += 1
add += 2 ** (x - 1)
m = max(m, i)
print(x)
def main():
t = int(input())
for i in range(t):
input()
arr = list(map(int, input().split()))
p... | FUNC_DEF ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR WHILE VAR BIN_OP VAR VAR VAR NUMBER VAR BIN_OP NUMBER BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def solve(lst):
if len(lst) == 1:
return -1
maximum = lst[0]
maximum_abs = 0
flag = True
for i in range(len(lst) - 1):
if lst[i] > lst[i + 1]:
flag = False
if maximum < lst[i]:
maximum = lst[i]
if maximum_abs < abs(maximum - lst[i]):
... | FUNC_DEF IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER IF VAR VAR VAR ASSIGN VAR VAR VAR IF VAR FUNC_CALL VAR BIN_OP VAR VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def msb(num):
cnt = 0
while num > 0:
num >>= 1
cnt += 1
return cnt
t = int(input(""))
for i in range(t):
n = int(input(""))
a = []
curr_input = input("")
for j in curr_input.split(" "):
a.append(int(j))
prev = a[0] if len(a) > 0 else 0
max_diff = 0
for n... | FUNC_DEF ASSIGN VAR NUMBER WHILE VAR NUMBER VAR NUMBER VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR STRING FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR STRING ASSIGN VAR LIST ASSIGN VAR FUNC_CALL VAR STRING FOR VAR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | t = int(input())
for e in range(t):
n = int(input())
a = list(map(int, input().split()))
s = 0
for i in range(len(a) - 1):
if a[i] > a[i + 1]:
s = max(s, a[i] - a[i + 1])
a[i + 1] = a[i]
if s == 0:
print(0)
else:
k = 0
n = 1
z = 0
... | 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 FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def solve():
n = int(input())
a = list(map(int, input().split()))
d = 0
mx = a[0]
for i in range(1, n):
if mx - a[i] > d:
d = mx - a[i]
if a[i] > mx:
mx = a[i]
ans = 0
c = 0
p = 1
while c < d:
c += p
p *= 2
ans += 1
... | 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 NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF BIN_OP VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
b = []
max = a[0]
for i in range(n):
if max < a[i]:
max = a[i]
b.append(max)
max = 0
for i in range(n):
if max < b[i] - a[i]:
max = b[i] - a[i]
print(0 if ma... | 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 LIST ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | import sys
def main_function():
import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
current_max_num = a[0]
max_difference = 0
for el in a:
if el < current_max_num:
... | IMPORT FUNC_DEF IMPORT ASSIGN 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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSI... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | def f(L):
maxm = 0
n = len(L)
for i in range(n - 1):
if L[i + 1] < L[i]:
maxm = max(maxm, L[i] - L[i + 1])
L[i + 1] = L[i]
if maxm == 0:
return 0
return len(bin(maxm)) - 2
n = int(input())
for i in range(n):
m = int(input())
L = list(map(int, input()... | FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER VAR VAR IF VAR NUMBER RETURN NUMBER RETURN BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER ASSIGN ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | tests = int(input())
for t in range(tests):
ans = 0
n = int(input())
num_arr = list(map(int, input().split(" ")))
for i in range(n - 1):
diff = num_arr[i + 1] - num_arr[i]
if diff >= 0:
continue
else:
diff = -diff
num_arr[i + 1] = num_arr[i]
... | 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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR IF VAR NUMBER ASSIGN VAR VAR ASSIGN ... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | t = int(input())
while t:
t -= 1
input()
a = list(map(int, input().split()))
x, m, d = 0, -1000000000.0, 0
for i in a:
m = max(m, i)
d = max(d, m - i)
while d:
d //= 2
x += 1
print(x) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR VAR NUMBER NUMBER NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR WHILE VAR VAR NUMBER VAR NUMBER EXPR FUNC_CAL... |
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{... | t = int(input())
for z in range(t):
n = int(input())
l = list(map(int, input().split()))
m = l[0]
s = 0
for i in range(1, n):
if l[i] > m:
m = l[i]
else:
s = max(s, -l[i] + m)
i = 1
while 2 ** (i - 1) < s:
i += 1
if 2 ** (i - 1) > 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 VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VA... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.