description stringlengths 171 4k | code stringlengths 94 3.98k | normalized_code stringlengths 57 4.99k |
|---|---|---|
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | q = int(input())
arr = [ord(i) for i in input()]
count = 0
max1 = max(arr)
while max1 != 0:
max1 = max(arr)
temp = []
for x in range(len(arr)):
if x == 0:
if arr[x] == max1 and len(arr) != 1:
if arr[x + 1] == max1 - 1:
temp.append(x)
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR WHILE VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR NUMBER IF VAR VAR VAR FUNC_CALL VAR VAR NUMBER IF VAR BIN_OP VAR NUMBER BIN_OP... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | n = int(input())
s = "_" + input() + "_"
for i in range(24, -1, -1):
c = chr(i + 1 + ord("a"))
d = chr(i + ord("a"))
flg = 1
while flg:
flg = 0
t = ""
for j in range(len(s) - 2):
if s[j + 1] == c and (s[j] == d or s[j + 2] == d):
flg = 1
el... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP BIN_OP STRING FUNC_CALL VAR STRING FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR BIN_OP VAR FUNC_CALL VAR STRING ASSIGN VAR NUMBER WHILE VAR ASSIGN VAR NUMBER ASSIGN VAR ... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | n = int(input())
s = input()
max_c = 0
while max_c != -1:
max_c = -1
idx = -1
for i in range(len(s)):
if i < len(s) - 1:
if ord(s[i + 1]) + 1 == ord(s[i]) and ord(s[i]) > max_c:
max_c = ord(s[i])
idx = i
if i > 0:
if ord(s[i - 1]) + 1 =... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER WHILE VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR BIN_OP FUNC_CALL VAR VAR NUMBER IF BIN_OP FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR VAR ASSIG... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | t = int(input())
st = input()
stlis = []
for i in range(t):
stlis.append(ord(st[i]) - 97)
stlis.append(-10)
for i in range(25, -1, -1):
j = 0
while True:
if j >= len(stlis) - 1:
break
if stlis[j] == i:
try:
if j == 0:
if stlis[j] - ... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR NUMBER WHILE NUMBER IF VAR BIN_OP FUNC_CALL VAR VAR NUMBER IF VAR VAR VAR IF VA... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | import sys
input = sys.stdin.readline
Alp = [chr(i) for i in range(97, 97 + 26)]
N = int(input())
S = input().rstrip()
ans = 0
for a in reversed(Alp):
while True:
update = False
for i in range(len(S)):
if S[i] != a:
continue
if i != 0 and ord(S[i - 1]) == ord... | IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR NUMBER BIN_OP NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR WHILE NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR VAR IF VAR NUMBER FUNC_... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | n = int(input())
s = input()
count = 0
for _ in range(n):
maxi = 0
idx = -1
lens = len(s)
for i in range(lens - 1):
if abs(ord(s[i]) - ord(s[i + 1])) == 1:
if ord(s[i]) > maxi:
maxi = ord(s[i])
idx = i
if ord(s[i + 1]) > maxi:
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER IF FUNC_CALL VAR V... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | from sys import stdin, stdout
n = int(stdin.readline().strip())
s = stdin.readline().strip()
def removable(i, x):
li = max(0, i - 1)
ri = min(x - 1, i + 1)
if ord(s[i]) == ord(s[li]) + 1 or ord(s[i]) == ord(s[ri]) + 1:
return True
return False
ansarr = []
for i in s:
ansarr.append(i)
fl... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER IF FUNC_CALL VAR VAR VAR BIN_OP FUNC_CALL VAR VAR VAR NUMBER FUNC_CALL VAR VAR VAR BIN_OP FUNC_CALL VAR VAR VAR NUMB... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | def check(arr, n):
max1 = 0
idx = -1
for i in range(n):
if i == 0:
if arr[i] - arr[i + 1] == 1 and n != 1:
if arr[i] > max1:
max1 = arr[i]
idx = i
elif i == n - 1:
if arr[i] - arr[i - 1] == 1 and n != 1:
... | FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR NUMBER IF BIN_OP VAR VAR VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER IF VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR IF VAR BIN_OP VAR NUMBER IF BIN_OP VAR VAR VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER IF VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR ... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | n = int(input())
n = abs(n)
s = input()
b = []
a = []
a.append(-1000000)
for i in range(n):
b.append(ord(s[i]) - ord("a"))
maxi = -1
j = -1
while True:
if len(b) == 1:
break
if b[0] == b[1] + 1:
maxi = b[0]
j = 0
for i in range(1, len(b) - 1):
if b[i] == b[i - 1] + 1 or b... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR LIST EXPR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE NUMBER IF FUNC_CALL VAR VAR NUMB... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | import sys
n = int(sys.stdin.readline())
rem = n
s = sys.stdin.readline()[:-1]
z = True
prev = "."
while z:
prev = "."
ind = -1
n = len(s)
for i in range(n):
if i - 1 >= 0:
if ord(s[i]) - ord(s[i - 1]) == 1:
if ord(s[i]) > ord(prev):
prev = s[i]
... | IMPORT ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR STRING WHILE VAR ASSIGN VAR STRING ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER IF BIN_OP FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR BIN_OP VAR N... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | def previous_char(x, y):
return ord(x) + 1 == ord(y)
n = int(input().strip())
s = list(input().strip())
ss = list(reversed(sorted([(s[i], i) for i in range(len(s))])))
i = 0
while i < len(ss):
max_index = ss[i][1]
if (
max_index + 1 < len(s)
and previous_char(s[max_index + 1], s[max_index]... | FUNC_DEF RETURN BIN_OP FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER WHILE VAR FUNC_CALL VAR VAR ASSIGN VA... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | import sys
def maxremovable(s):
mx = -1
for i in range(len(s)):
if i - 1 >= 0 and ord(s[i]) - ord(s[i - 1]) == 1:
if mx == -1:
mx = i
elif s[mx] < s[i]:
mx = i
if i + 1 < len(s) and ord(s[i]) - ord(s[i + 1]) == 1:
if mx == -1:... | IMPORT FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER BIN_OP FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER IF VAR NUMBER ASSIGN VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR IF BIN_OP VAR NUMBER FUNC_CALL VAR VAR BIN_OP FUNC_CALL VAR VAR VAR FUNC_CALL VAR V... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | n = int(input())
s = input()
l = []
for i in range(n):
t = ord(s[i])
if t not in l:
l.append(t)
l.sort(reverse=True)
c = 0
while len(l) > 1:
j = 0
f = False
while j < len(s):
if ord(s[j]) == l[0]:
if j == 0:
if ord(s[1]) == l[0] - 1:
s ... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER WHILE FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR FUNC_CALL VAR VAR IF FUNC_... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | def filtered(s, filt):
buf = ""
for tp in zip(s, filt):
if not tp[1]:
buf += tp[0]
return buf
n = int(input())
s = input()
for c in range(25, 0, -1):
deleted = [False] * len(s)
for i in range(len(s)):
j = i + 1
while j < len(s) and c + ord("a") == ord(s[j]) and ... | FUNC_DEF ASSIGN VAR STRING FOR VAR FUNC_CALL VAR VAR VAR IF VAR NUMBER VAR VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR NUMBER... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | n = int(input())
alphabet = "abcdefghijklmnopqrstuvwxyz"
y = input()
ans = 0
for i in range(25):
for j in range(len(y)):
cont = True
while cont == True:
if j < len(y) and y[len(y) - 1 - j] == alphabet[25 - i]:
if (
j < len(y) - 1
an... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR STRING ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER WHILE VAR NUMBER IF VAR FUNC_CALL VAR VAR VAR BIN_OP BIN_OP FUNC_CALL VAR VAR NUMBER VAR VAR BIN_OP NUMBER VAR IF VAR BIN_OP FUNC_CAL... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | n, s = int(input()), input()
for c in "bcdefghijklmnopqrstuvwxyz"[::-1]:
d = True
while d:
d = False
pos = [k for k in range(len(s)) if s[k] == c]
for k in pos:
if (
k + 1 < len(s)
and ord(s[k + 1]) - ord(c) == -1
or k >= 1
... | ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR STRING NUMBER ASSIGN VAR NUMBER WHILE VAR ASSIGN VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR FOR VAR VAR IF BIN_OP VAR NUMBER FUNC_CALL VAR VAR BIN_OP FUNC_CALL VAR VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER BI... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | n = int(input())
s = input()
i = 0
a = "a"
ind = -1
f = True
while f:
ind = -1
a = "a"
i = 0
while i < len(s):
if i == 0:
if len(s) >= 2:
if ord(s[i]) == ord(s[i + 1]) + 1:
if ord(a) < ord(s[i]):
a = s[i]
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR ASSIGN VAR NUMBER ASSIGN VAR STRING ASSIGN VAR NUMBER WHILE VAR FUNC_CALL VAR VAR IF VAR NUMBER IF FUNC_CALL VAR VAR NUMBER IF FUNC_CALL VAR VAR VAR BIN_OP FUNC_CALL VAR VAR ... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | n = int(input())
s = [i for i in input()]
q = []
def ok(st, t):
if len(st) == 1:
return True
if (
st[0] == t
and ord(st[0]) - ord(st[1]) == 1
or st[-1] == t
and ord(st[-1]) - ord(st[-2]) == 1
):
return False
for i in range(1, len(st) - 1):
if st[... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR ASSIGN VAR LIST FUNC_DEF IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER IF VAR NUMBER VAR BIN_OP FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR VAR NUMBER NUMBER VAR NUMBER VAR BIN_OP FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR VAR NUMBER NUMBER RETURN NUMBER FOR VA... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | n = int(input())
s = [(ord(i) - 97) for i in input()]
ans = 0
while 1:
mxi = mx = -1
for i in range(len(s)):
if i and s[i - 1] == s[i] - 1 and s[i] > mx:
mx = s[i]
mxi = i
if i + 1 < len(s) and s[i + 1] == s[i] - 1 and s[i] > mx:
mx = s[i]
mxi = i
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR FUNC_CALL VAR ASSIGN VAR NUMBER WHILE NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR IF BIN_OP VAR NUMBER FUNC_CALL... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | sl = int(input())
s = input()
v = [[s[x], 0] for x in range(sl)]
for i in range(sl):
if i - 1 >= 0 and ord(v[i - 1][0]) == ord(v[i][0]) - 1:
v[i][1] += 1
if i + 1 < sl and ord(v[i + 1][0]) == ord(v[i][0]) - 1:
v[i][1] += 1
ans = 0
def findmax(va):
ind = -1
ans = ["a", 0]
for i in r... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR LIST VAR VAR NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER BIN_OP FUNC_CALL VAR VAR VAR NUMBER NUMBER VAR VAR NUMBER NUMBER IF BIN_OP VAR NUMBER VAR FUNC_CALL VAR VA... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | n = int(input())
s = input()
ans = 0
for i in range(25, 0, -1):
while 1:
c = [chr(ord("a") + i), chr(ord("a") + i - 1)]
tmp = []
for j in range(len(s)):
if j > 0 and s[j] == c[0] and s[j - 1] == c[1]:
tmp.append(j)
elif j < len(s) - 1 and s[j] == c[0] ... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER WHILE NUMBER ASSIGN VAR LIST FUNC_CALL VAR BIN_OP FUNC_CALL VAR STRING VAR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR STRING VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF V... |
You are given a string $s$ consisting of lowercase Latin letters. Let the length of $s$ be $|s|$. You may perform several operations on this string.
In one operation, you can choose some index $i$ and remove the $i$-th character of $s$ ($s_i$) if at least one of its adjacent characters is the previous letter in the La... | def solve_test_case(t):
n = int(input())
s = str(input())
res = 0
removed = True
while removed:
removed = False
for ci in reversed(range(26)):
c = chr(ord("a") + ci)
prev_c = chr(ord("a") + ci - 1)
new_s = []
for i in range(len(s)):
... | FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR STRING VAR ASSIGN VAR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR STRING VAR NUMBE... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(n):
if i + 2 < n:
if a[i] == a[i + 1]:
continue
elif a[i] < a[i + 1]:
if a[i + 1] <= a[i + 2]:
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 NUMBER FOR VAR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER VAR IF VAR VAR VAR BIN_OP VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER IF VAR BIN_OP ... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
for _ in range(int(input())):
n = int(input())
arr = [int(x) for x in input().split()]
ans = n + n - 1
for i in range(n - 2):
if (arr[i] - arr[i + 1]) * (arr[i + 1] - arr[i + 2]) < 0:
ans += 1
for i in range(n - 3):
... | IMPORT ASSIGN VAR FUNC_CALL FUNC_CALL VAR STRING 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 BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF BIN_OP BIN_OP VAR VAR VAR BIN_OP VAR NUMBE... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | for _ in range(int(input())):
n = int(input())
nums = list(map(int, input().split()))
ans = n * 2 - 1
for i in range(2, n):
if nums[i - 1] < nums[i - 2]:
ans += nums[i - 1] < nums[i]
elif nums[i - 1] > nums[i - 2]:
ans += nums[i - 1] > nums[i]
for i in range(3... | 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 BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR VAR BIN_OP VAR NUMBER VAR VAR IF VAR ... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | import sys
input = sys.stdin.readline
def solve():
n = int(input())
arr = list(map(int, input().split()))
ans = n + n - 1
for i in range(n - 2):
if (
arr[i] == arr[i + 1]
or arr[i + 1] == arr[i + 2]
or arr[i] <= arr[i + 1] <= arr[i + 2]
or arr[i... | IMPORT ASSIGN VAR VAR 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 BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR VAR VAR BIN_OP VAR NUM... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def is_good(p, q, r):
if q > max(p, r) or q < min(p, r):
return True
else:
return False
t = int(input())
for i in range(t):
n = int(input())
a = list(map(int, input().split()))
good = n + (n - 1)
for i in range(0, n - 3, 1):
bool = (
is_good(a[i], a[i + 1], ... | FUNC_DEF IF VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR VAR RETURN NUMBER 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 FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
for i in range(t):
n = int(input())
a = list(map(int, input().split()))
res = 0
for j in range(n):
kx = min(j + 4, n)
for k in range(j, kx):
bl = True
for l in range(j, k):
for m in range(l + 1, k):
if a[l] <= 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 NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FU... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
for test in range(t):
n = int(input())
arr = list(map(int, input().split()))
ans = 2 * n - 1
for i in range(n - 2):
a = arr[i]
b = arr[i + 1]
c = arr[i + 2]
if b > max(a, c) or b < min(a, c):
ans += 1
for i in range(n - 3):
a = arr... | 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 BIN_OP NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
for _ in range(0, t):
n = int(input())
x = list(map(int, input().split()))
ans = 2 * n - 1
cnt = 0
cnn = 0
for i in range(2, n):
if x[i - 1] >= min(x[i], x[i - 2]) and x[i - 1] <= max(x[i - 2], x[i]):
cnn += 1
for i in range(3, n):
if x[i - 1] >= ... | 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 VAR ASSIGN VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR BIN_OP VAR NUMBER FUNC_... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | for t in range(int(input())):
n = int(input())
a = [*map(int, input().split())]
a1, a2, a3, a4 = 0, 0, 0, 0
res = 0 if n < 3 else int(not (a[-3] >= a[-2] >= a[-1] or a[-3] <= a[-2] <= a[-1]))
for i in range(n - 4, -1, -1):
a1, a2, a3, a4 = a[i], a[i + 1], a[i + 2], a[i + 3]
if not (a... | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR VAR VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FOR VAR FUNC_... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def is_bad(l):
for i in range(2):
for j in range(i + 1, 3):
for k in range(j + 1, 4):
if l[i] >= l[j] >= l[k] or l[i] <= l[j] <= l[k]:
return True
return False
def solve():
n = int(input())
inp = list(map(int, input().split()))
ans = n + n - ... | FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER IF VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CAL... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def solve(a):
result = 2 * len(a) - 1
for i in range(len(a) - 2):
if not check(a[i : i + 3]):
result += 1
for i in range(len(a) - 3):
if not check(a[i : i + 4]):
result += 1
return result
def check(a):
first, second = 0, 0
first_result = False
for el... | FUNC_DEF ASSIGN VAR BIN_OP BIN_OP NUMBER FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER IF FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER IF FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR VAR NUM... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
for i in range(t):
n = int(input())
arr = [int(i) for i in input().split()]
counter = 2 * n - 1
i = 3
while i < n:
a, b, c, d = arr[i - 3 : i + 1]
if b > d >= a > c or c > d >= a > b or c > a >= d > b or c < d <= a < b:
counter += 1
i += 1
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 VAR ASSIGN VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR NUMBER WHILE VAR VAR ASSIGN VAR VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR VAR VAR VA... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | for _ in range(int(input())):
n = int(input())
l = list(map(int, input().split()))
ans = n + n - 1
for i in range(1, n - 1):
a = l[i - 1]
b = l[i]
c = l[i + 1]
if abs(a - b) + abs(b - c) != abs(a - c):
ans += 1
for i in range(n - 3):
a = l[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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def good(a, b, c):
return not (a <= b <= c or a >= b >= c)
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
ans = n + (n - 1)
for i in range(n - 2):
if good(a[i], a[i + 1], a[i + 2]):
ans += 1
if (
i < n - 3
... | FUNC_DEF RETURN VAR VAR VAR VAR 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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMB... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | ans = []
for _ in range(int(input())):
n = int(input())
u = list(map(int, input().split()))
cur = 0
cur += n
cur += n - 1
for i in range(2, n):
if u[i - 2] <= u[i - 1] <= u[i]:
continue
if u[i] <= u[i - 1] <= u[i - 2]:
continue
cur += 1
for i i... | 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 ASSIGN VAR NUMBER VAR VAR VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR VAR IF VAR VAR V... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
for p in range(0, t):
n = int(input())
l = list(map(int, input().split()))
s = 2 * n - 1
for i in range(0, n - 2):
if l[i + 1] > l[i] and l[i + 1] > l[i + 2] or l[i] > l[i + 1] < l[i + 2]:
s = s + 1
for i in range(0, n - 3):
if (l[i + 1] < l[i] < l[i + 2]... | 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 VAR ASSIGN VAR BIN_OP BIN_OP NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR VAR VAR BIN_OP VAR NUMB... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def checktriple(ind, array):
a, b, c = array[ind], array[ind + 1], array[ind + 2]
if a >= b and b >= c:
return False
elif a <= b and b <= c:
return False
return True
t = int(input())
for i in range(t):
n = int(input())
array = [int(j) for j in input().split()]
if n >= 3:
... | FUNC_DEF ASSIGN VAR VAR VAR VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER IF VAR VAR VAR VAR RETURN NUMBER IF VAR VAR VAR VAR RETURN NUMBER 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 VAR VAR FUNC_CALL FUNC_CALL VAR... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | from sys import *
input = stdin.readline
for _ in range(int(input())):
n = int(input())
l = list(map(int, input().split()))
ans = 2 * n - 1
for i in range(n - 2):
a, b, c = l[i : i + 3]
if a > b < c or a < b > c:
ans += 1
if i < n - 3:
d = l[i + 3]
... | ASSIGN 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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP BIN_OP NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR VAR BIN_OP VAR NUMBER IF VAR VAR VAR VAR VA... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | for t in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
ans = n * 2 - 1
if n < 3:
print(ans)
elif n == 3:
if a[0] >= a[1] >= a[2] or a[0] <= a[1] <= a[2]:
print(ans)
else:
print(ans + 1)
else:
for i in range(n - 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 BIN_OP BIN_OP VAR NUMBER NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR VAR IF VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER E... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def check(a):
l = len(a)
if l == 1 or l == 2:
return True
elif l > 4:
return False
elif l == 3:
if a[0] <= a[1] and a[1] <= a[2]:
return False
elif a[0] >= a[1] and a[1] >= a[2]:
return False
else:
return True
elif a[1] < a[... | FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER IF VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER RETURN NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER RETURN NUMBER RETURN NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUM... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
for tests in range(t):
n = int(input())
a = list(map(int, input().split(" ")))
ans = 0
for i in range(1, n - 1):
if (
a[i - 1] >= a[i]
and a[i] >= a[i + 1]
or a[i - 1] <= a[i]
and a[i] <= a[i + 1]
):
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 STRING ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR VAR VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | for t in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
cnt = 0
for w in range(3, 5):
for i in range(len(a) - w + 1):
if w == 3:
if (a[i + 1] - a[i]) * (a[i + 2] - a[i + 1]) < 0:
cnt += 1
elif (
... | 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 NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR VAR VAR NUMBER IF VAR NUMBER IF BIN_OP BIN_OP VAR BIN_OP VAR... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def argsort(a):
ind, _ = zip(*sorted(enumerate(a), key=lambda x: x[1]))
return ind
def solve(A):
out = len(A) * 2 - 1
for i in range(len(A) - 2):
ind = argsort(A[i : i + 3])
if (
ind in {(0, 2, 1), (1, 2, 0), (2, 0, 1), (1, 0, 2)}
and A[i + 1] != A[i]
... | FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR BIN_OP BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER IF VAR NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER N... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def check_if_good(a, b, c):
if a <= b <= c or a >= b >= c:
return False
return True
def solve(n, arr):
result = 2 * n - 1
for x in range(n - 2):
if check_if_good(arr[x], arr[x + 1], arr[x + 2]):
result += 1
for x in range(n - 3):
if (
check_if_good(a... | FUNC_DEF IF VAR VAR VAR VAR VAR VAR RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR BIN_OP BIN_OP NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMB... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | one = 1
for _ in range(int(input())):
zero = 0
n = int(input())
one = 1
a = list(map(int, input().split()))
zero = 0
ans = n + n - 1
one = 1
for i in range(0, n - 2):
if a[i] <= a[i + 1] <= a[i + 2] or a[i] >= a[i + 1] >= a[i + 2]:
one = 1
continue
... | ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR NUMBER 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 NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_O... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def dist(x, y, i, j):
return abs(x - y) + abs(i - j)
def check(a, l, r):
for i in range(l, r + 1):
for j in range(l, r + 1):
for k in range(l, r + 1):
if i == j or j == k or k == i:
continue
elif dist(a[i], a[j], i, j) == dist(a[i], a[k],... | FUNC_DEF RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR BIN_OP VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER IF VAR VAR VAR VAR VAR VAR IF FUNC_CALL VAR VAR VAR VAR VAR VAR VAR BIN_OP FUNC_CALL VAR VAR VAR V... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def calc(l, n):
for i in range(l, n + 1, 1):
for j in range(i + 1, n + 1, 1):
for k in range(j + 1, n + 1, 1):
if a[i] <= a[j] <= a[k] or a[i] >= a[j] >= a[k]:
return False
return True
t = int(input())
for z in range(t):
n = int(input())
a = list... | FUNC_DEF FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER NUMBER IF VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | import sys
t = int(sys.stdin.readline())
while t > 0:
n = int(sys.stdin.readline())
a = list(map(int, input().split()))
c = 2 * n - 1
if n <= 2:
print(c)
else:
for i in range(n - 2):
j = i + 1
k = j + 1
if a[i] >= a[j] >= a[k] or a[i] <= a[j] <= a... | IMPORT 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 BIN_OP BIN_OP NUMBER VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER AS... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | T = int(input())
for _ in range(T):
N = int(input())
A = [int(a) for a in input().split()]
ans = N + N - 1
for i in range(N - 2):
a, b, c = A[i], A[i + 1], A[i + 2]
if a > b < c or a < b > c:
ans += 1
for i in range(N - 3):
a, b, c, d = A[i], A[i + 1], A[i + 2], 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 VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER IF VAR V... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | n = int(input())
def analyze_4(dec, b, d):
if d is None:
return 3
if not dec:
if d >= b:
return 3
else:
return 4
elif d <= b:
return 3
else:
return 4
def analyze_3(a, b, c, d=None):
if a == b:
return 2
elif a < b:
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF IF VAR NONE RETURN NUMBER IF VAR IF VAR VAR RETURN NUMBER RETURN NUMBER IF VAR VAR RETURN NUMBER RETURN NUMBER FUNC_DEF NONE IF VAR VAR RETURN NUMBER IF VAR VAR IF VAR VAR RETURN NUMBER IF VAR VAR VAR NONE VAR VAR VAR VAR RETURN NUMBER RETURN FUNC_CALL VAR NUMBER VAR VAR ... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | import sys
input = sys.stdin.readline
t = int(input())
for tests in range(t):
n = int(input())
A = list(map(int, input().split()))
if n == 1:
print(1)
continue
if n == 2:
print(3)
continue
ANS = 3
for i in range(n - 2):
if A[i] <= A[i + 1] <= A[i + 2] or ... | 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 IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP ... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
for case in range(t):
n = int(input())
b = [int(x) for x in input().split()]
threes = 0
for i in range(2, n):
if (
b[i] >= b[i - 1]
and b[i - 1] >= b[i - 2]
or b[i] <= b[i - 1]
and b[i - 1] <= b[i - 2]
):
pass
... | 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 VAR IF VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR VAR VAR BIN_OP VAR NUMBER V... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def Manhattan_distance(p, q):
return abs(p[0] - q[0]) + abs(p[1] - q[1])
def is_bad_triple(p, q, r):
x = Manhattan_distance(p, q)
y = Manhattan_distance(p, r)
z = Manhattan_distance(r, q)
X = [x, y, z]
return X[0] == X[1] + X[2] or X[1] == X[0] + X[2] or X[2] == X[1] + X[0]
t = int(input())
... | FUNC_DEF RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR LIST VAR VAR VAR RETURN VAR NUMBER BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER BIN_OP VAR NUMBER... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def ok3(a1, a2, a3):
if (a2 - a1) * (a2 - a3) > 0:
return 1
return 0
def ok4(a1, a2, a3, a4):
if ok3(a1, a2, a3) and ok3(a1, a2, a4) and ok3(a1, a3, a4) and ok3(a2, a3, a4):
return 1
return 0
t = int(input())
for i in range(t):
n = int(input())
a = list(map(int, input().split... | FUNC_DEF IF BIN_OP BIN_OP VAR VAR BIN_OP VAR VAR NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF IF FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FU... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def is_triplet(a, b, c):
if a <= b and b <= c:
return True
if a >= b and b >= c:
return True
return False
T = int(input())
for t in range(T):
n = int(input())
arr = list(map(int, input().split()))
ct = n + n - 1
for i in range(n - 2):
if is_triplet(arr[i], arr[i + 1... | FUNC_DEF IF VAR VAR VAR VAR RETURN NUMBER IF VAR VAR VAR VAR RETURN NUMBER 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 FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VA... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def solve():
n = int(input())
a = [int(i) for i in input().split(" ")]
ans = 2 * n - 1
for i in range(n - 2):
if not (
a[i] <= a[i + 1]
and a[i + 1] <= a[i + 2]
or a[i] >= a[i + 1]
and a[i + 1] >= a[i + 2]
):
ans += 1
for i ... | FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR BIN_OP BIN_OP NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUM... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
for o in range(t):
ans = 0
n = int(input())
l = list(map(int, input().strip().split()))
if n == 1:
print(1)
continue
elif n == 2:
print(3)
continue
for i in range(n - 2):
ans += 2
b0 = l[i]
b1 = l[i + 1]
lower = -10... | 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 IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER V... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
def check3(a, b, c):
return (a - b) * (c - b) > 0
def check4(a, b, c, d):
return check3(a, b, c) and check3(a, b, d) and check3(a, c, d) and check3(b, c, d)
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
res = n + n - 1
for i in range(n - 2):
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF RETURN BIN_OP BIN_OP VAR VAR BIN_OP VAR VAR NUMBER FUNC_DEF RETURN FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL V... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
h = []
i, j = 0, 1
ans = 1
while j < n:
d = []
if i + 3 < j:
i += 1
notgood = True
while i + 1 < j and notgood:
notgood = False
bad = 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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER WHILE VAR VAR ASSIGN VAR LIST IF BIN_OP VAR NUMBER VAR VAR NUMBER ASSIGN VAR NUMBER WHILE BIN_OP VAR ... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def sol_mansub(n, ar):
res = 0
for i in range(len(ar)):
if i >= n - 2:
l = n - i
res += l * (l + 1) // 2
break
a, b, c = ar[i : i + 3]
if a <= b <= c or a >= b >= c:
res += 2
continue
l = 3
if i + 3 < n:
... | FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR VAR VAR VAR BIN_OP VAR NUMBER IF VAR VAR VAR VAR VAR VAR VAR NUMBER ASSIGN VAR NUMBER IF BIN_OP VAR NUMBER VAR ASSIGN VAR VAR BIN_OP VAR NUM... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | PI = 3.141592653589793
INF = float("inf")
MOD = 1000000007
def bin32(num):
return "{0:032b}".format(num)
def add(x, y):
return (x + y) % MOD
def sub(x, y):
return (x - y + MOD) % MOD
def mul(x, y):
return x * y % MOD
def gcd(x, y):
if y == 0:
return x
return gcd(y, x % y)
def... | ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR NUMBER FUNC_DEF RETURN FUNC_CALL STRING VAR FUNC_DEF RETURN BIN_OP BIN_OP VAR VAR VAR FUNC_DEF RETURN BIN_OP BIN_OP BIN_OP VAR VAR VAR VAR FUNC_DEF RETURN BIN_OP BIN_OP VAR VAR VAR FUNC_DEF IF VAR NUMBER RETURN VAR RETURN FUNC_CALL VAR VAR BIN_OP VAR VAR FUNC... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def _sum_(n):
res = 0
for i in range(1, min(5, n + 1)):
res += n + 1 - i
return res
def test(b):
for i in range(4):
for j in range(i + 1, 4):
for k in range(j + 1, 4):
if b[i] <= b[j] <= b[k] or b[i] >= b[j] >= b[k]:
return True
retur... | FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR NUMBER VAR RETURN VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER IF VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VA... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | for _ in range(int(input())):
n = int(input())
a = [int(x) for x in input().split()]
ans = n + n - 1
for i in range(2, n):
if a[i - 2] <= a[i - 1] <= a[i]:
continue
if a[i - 2] >= a[i - 1] >= a[i]:
continue
ans += 1
for i in range(3, n):
if a[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 BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR VAR IF VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
def dist(a, b, c, d):
return abs(a - c) + abs(b - d)
def bad(a, b, c, d, e, f):
return (
dist(a, b, c, d) == dist(a, b, e, f) + dist(e, f, c, d)
or dist(a, b, e, f) == dist(a, b, c, d) + dist(e, f, c, d)
or dist(e, f, c, d) == dist(a, b, e, f) + dist(a, b, c, d)
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR BIN_OP VAR VAR FUNC_DEF RETURN FUNC_CALL VAR VAR VAR VAR VAR BIN_OP FUNC_CALL VAR VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR BIN_OP FUNC_CALL VAR VAR VAR VAR VAR FUNC_CALL VAR VAR VA... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
ans = n + (n - 1)
for i in range(n):
if i + 2 < n:
if (
arr[i + 1] >= arr[i]
and arr[i + 2] >= arr[i + 1]
or arr[i + 1] <= arr[i]
and 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 BIN_OP VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER VAR IF VAR BIN_OP VAR NUMBER VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUM... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
for i in range(t):
n = int(input())
a = list(map(int, input().split()))
c = n + max(n - 1, 0) + max(n - 2, 0) + max(n - 3, 0)
for j in range(n - 2):
if (
a[j] <= a[j + 1]
and a[j + 1] <= a[j + 2]
or a[j] >= a[j + 1]
and a[j + 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 VAR ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER NUM... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def check(a, b, c):
if a <= b and b <= c or a >= b and b >= c:
return True
else:
return False
t = int(input())
for _ in range(t):
n = int(input())
a = [0] + list(map(int, input().split()))
w = n + n - 1
x = 0
if n >= 3:
x += n - 2
for i in range(1, n - 1):
... | FUNC_DEF IF VAR VAR VAR VAR VAR VAR VAR VAR RETURN NUMBER 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 BIN_OP LIST NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR NUMBER ... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def check(arr):
ret = True
for one in range(4):
for two in range(4):
for three in range(4):
if one != two and two != three and one != three:
dist = [
abs(arr[one][0] - arr[two][0]) + abs(arr[one][1] - arr[two][1]),
... | FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR VAR VAR VAR ASSIGN VAR LIST BIN_OP FUNC_CALL VAR BIN_OP VAR VAR NUMBER VAR VAR NUMBER FUNC_CALL VAR BIN_OP VAR VAR NUMBER VAR VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR VAR NUMBER VAR VAR NUM... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def checkIfValidArr(arr):
if len(arr) <= 2:
return True
if len(arr) >= 5:
return False
for i in range(len(arr)):
for j in range(i + 1, len(arr)):
for k in range(j + 1, len(arr)):
if (
arr[i] <= arr[j]
and arr[j] <= a... | FUNC_DEF IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR IF VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR RETU... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def check(a, i):
c = 0
if (
abs(a[i] - a[i + 2]) + 2
!= abs(a[i] - a[i + 1]) + 1 + abs(a[i + 1] - a[i + 2]) + 1
):
if (
abs(a[i] - a[i + 3]) + 3
!= abs(a[i] - a[i + 1]) + 1 + abs(a[i + 1] - a[i + 3]) + 2
):
if (
abs(a[i] - a... | FUNC_DEF ASSIGN VAR NUMBER IF BIN_OP FUNC_CALL VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP BIN_OP FUNC_CALL VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER NUMBER FUNC_CALL VAR BIN_OP VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER IF BIN_OP FUNC_CALL VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER NUMBER BIN_OP... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | A = []
t = int(input())
def isg(l, r):
for i in range(l, r + 1):
for j in range(i + 1, r + 1):
for k in range(j + 1, r + 1):
if A[i] >= A[j] and A[j] >= A[k]:
return False
if A[i] <= A[j] and A[j] <= A[k]:
return False
... | ASSIGN VAR LIST ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR VAR VAR VAR VAR VAR VAR RETURN NUMBER IF VAR VAR VAR VAR VAR VAR VAR VAR RETURN NUMBE... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | from sys import stdin
def A():
t = int(stdin.readline())
while t:
t -= 1
s = int(stdin.readline())
cnt = []
res = 1
cnt.append(1)
while s > res:
s -= res
res += 2
if s < res:
cnt.append(s)
else:
... | FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR NUMBER EXPR FUNC_CALL VAR NUMBER WHILE VAR VAR VAR VAR VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR FUNC_... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def d(p1, p2):
return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1])
for _ in range(int(input())):
n = int(input())
a = [int(x) for x in input().split()]
sol = 0
for i in range(n - 2):
done = False
p1 = [a[i + 0], 1]
p2 = [a[i + 1], 2]
p3 = [a[i + 2], 3]
ds = [d(p1... | FUNC_DEF RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER 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 VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN ... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
for i in range(t):
n = int(input())
a = list(map(int, input().split(" ")))
dp = [(0) for i in range(n)]
for k in range(n):
maxs = [[a[k], k]]
mins = [[a[k], k]]
cnt = 1
if k >= n - 2:
cnt = n - k
else:
for pro in range(k + ... | 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 STRING ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR LIST LIST VAR VAR VAR ASSIGN VAR LIST LIST VAR VAR VAR ASSIGN VAR... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
for _ in range(t):
n = int(input())
arr = list(map(int, input().split()))
if n < 3:
print(2 * n - 1)
else:
k = 0
ans = 2 * n - 1
for i in range(2, n):
if (
arr[i - 2] < arr[i - 1]
and arr[i - 1] > arr[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 IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR N... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def fun(arr):
total = 2 * n - 1
for i in range(n - 2):
total += (arr[i] - arr[i + 1]) * (arr[i + 1] - arr[i + 2]) < 0
for i in range(n - 3):
total += (arr[i + 1] - arr[i + 3]) * (arr[i + 3] - arr[i + 2]) > 0 and (
arr[i + 1] - arr[i]
) * (arr[i] - arr[i + 2]) > 0
prin... | FUNC_DEF ASSIGN VAR BIN_OP BIN_OP NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VA... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def ok(b):
if len(b) <= 2:
return True
n = len(b)
for i in range(n):
for j in range(i + 1, n):
for k in range(j + 1, n):
if b[i] >= b[j] >= b[k] or b[i] <= b[j] <= b[k]:
return False
return True
def findCount():
n = int(input())
n... | FUNC_DEF IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def fuk(a):
if a[0] <= a[1] <= a[2]:
return 1
if a[0] >= a[1] >= a[2]:
return 1
return 0
def fukk(a):
if a[0] <= a[1] <= a[2]:
return 1
if a[1] <= a[2] <= a[3]:
return 1
if a[0] <= a[2] <= a[3]:
return 1
if a[0] <= a[1] <= a[3]:
return 1
... | FUNC_DEF IF VAR NUMBER VAR NUMBER VAR NUMBER RETURN NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF IF VAR NUMBER VAR NUMBER VAR NUMBER RETURN NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER RETURN NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER RETURN NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER RE... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | import sys
def check_triple(x, y, z):
return (x - y) * (y - z) < 0
def solve(arr):
n = len(arr)
base = n + (n - 1)
triple = 0
for i in range(2, n):
to_check = arr[i - 2 : i + 1]
if check_triple(*to_check):
triple += 1
quadro = 0
for i in range(3, n):
c... | IMPORT FUNC_DEF RETURN BIN_OP BIN_OP VAR VAR BIN_OP VAR VAR NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER IF FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR N... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
i = 2
j = 0
goods = n + n - 1
last_good = False
while i < len(a):
if not a[i - 2] <= a[i - 1] <= a[i] and not a[i - 2] >= a[i - 1] >= a[i]:
if last_good:
if (
... | 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 BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR NUMBER WHILE VAR FUNC_CALL VAR VAR IF VAR BIN_OP VAR NUMBER VA... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def main():
t = int(input())
for _ in range(t):
n = int(input())
a = [int(word) for word in input().split()]
dp = [(1) for i in range(n)]
for i in range(1, n):
cur = 1
up = []
down = []
for j in range(i - 1, max(i - 5, -1), -1):
... | 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 VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR FUNC_CALL VAR BIN_O... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | from itertools import combinations
from sys import stdin
input = stdin.readline
def check(d):
for i in range(4):
b = d[:i] + d[i + 1 :]
if b == sorted(b) or b == sorted(b, reverse=True):
return False
return True
for _ in range(int(input())):
n = int(input())
a = list(map... | ASSIGN VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER IF VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR NUMBER RETURN NUMBER RETURN 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_... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def o(p1):
r = len(p1)
if r < 3:
return True
if r >= 5:
return False
for i in range(r):
for k in range(i + 1, r):
for s in range(k + 1, r):
if (
p1[i] <= p1[k]
and p1[k] <= p1[s]
or p1[i] >= p... | FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_C... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def check(arr):
for a in range(len(arr) - 2):
for b in range(a + 1, len(arr) - 1):
for c in range(b + 1, len(arr)):
r1 = arr[b] - arr[a]
r2 = arr[c] - arr[b]
if r1 <= 0 and r2 <= 0:
return True
if r1 >= 0 and r2 ... | FUNC_DEF FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR IF VAR NUMBER VAR NUMBER RETURN NUMBER IF VAR NUMBER VAR NU... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | for _ in range(int(input())):
n = int(input())
l = list(map(int, input().split()))
ans = n + n - 1
f = 0
for i in range(n - 2):
if (l[i + 1] - l[i]) * (l[i + 2] - l[i + 1]) < 0:
ans += 1
for i in range(n - 3):
if (l[i + 1] - l[i]) * (l[i + 2] - l[i]) < 0 and (l[i + 3]... | 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 BIN_OP VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR VAR BIN_OP VAR BIN_OP V... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | f = lambda x: x == sorted(x) or x[::-1] == sorted(x)
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
o = 0
for i in range(n - 2):
if not f(a[i : i + 3]):
o += 1
for i in range(n - 3):
if not any(f([a[i + j] for j in range(4) if j != k]) ... | ASSIGN VAR VAR FUNC_CALL VAR VAR VAR NUMBER 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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER V... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
ans = 0
ans += n
ans += n - 1
for i in range(n - 2):
if (a[i + 1] - a[i]) * (a[i + 2] - a[i + 1]) < 0:
ans += 1
for i in range(n - 3):
if (a[i + 1] - a[i]) * (a[i + 2] - a[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 VAR VAR VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR VAR BIN_OP VAR BIN... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
def checker(brr):
m = len(brr)
for i in range(m):
for j in range(i + 1, m):
for k in range(j + 1, m):
if (
brr[i] <= brr[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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF VAR VAR V... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | for _ in range(int(input())):
n = int(input())
yaxis = list(map(int, input().split()))
count = 0
for i in range(n):
if i - 2 < 0:
count += i + 1
continue
count += 2
j = i - 1
k = i - 2
count += 1
if yaxis[i] >= yaxis[j] and yaxis[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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER V... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | import sys
input = lambda: sys.stdin.readline().rstrip()
def solve_tc():
ans = 0
n = int(input())
s = list(map(int, input().split()))
for i in range(n - 2):
if (
s[i + 1] < s[i]
and s[i + 1] < s[i + 2]
or s[i + 1] > s[i]
and s[i + 1] > s[i + 2]
... | IMPORT ASSIGN VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF 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 BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR VA... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | n_tests = int(input())
def is_good(array):
l = len(array)
for i in range(l):
for j in range(i + 1, l):
for k in range(j + 1, l):
if (
array[k] >= array[j]
and array[j] >= array[i]
or array[k] <= array[j]
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR ... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | import sys
input = sys.stdin.readline
def main():
def good(i, j, k):
return not (ar[k] >= ar[j] >= ar[i] or ar[k] <= ar[j] <= ar[i])
t = int(input())
for _ in range(t):
n = int(input())
ar = list(map(int, input().split()))
ans = 2 * n - 1
bad = [False] * n
... | IMPORT ASSIGN VAR VAR FUNC_DEF FUNC_DEF RETURN VAR VAR VAR VAR VAR VAR VAR VAR 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 FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR ... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def check(a):
if len(a) == 3:
if a[0] >= a[1] >= a[2] or a[0] <= a[1] <= a[2]:
return False
return True
else:
for i in range(4):
b = []
for j in range(4):
if i != j:
b.append(a[j])
if check(b) == False:
... | FUNC_DEF IF FUNC_CALL VAR VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER RETURN NUMBER RETURN NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR VAR VAR IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF FOR VAR F... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | def bad_triplet(a, b, c):
if a <= b and b <= c:
return True
if a >= b and b >= c:
return True
return False
def solve():
n = int(input())
arr = [int(x) for x in input().split()]
if n < 3:
return n + n - 1
good_subarrays = n + n - 1 + n - 2 + n - 3
for i in range(... | FUNC_DEF IF VAR VAR VAR VAR RETURN NUMBER IF VAR VAR VAR VAR RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR NUMBER RETURN BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP VAR VAR NUMBER VAR NUMB... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | import sys
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number):
return [LI() for _ in range(rows_number)]
def LI1():
return list(map(int1, sys.stdin.readline... | IMPORT 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 FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CAL... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | answers = []
def solve(n, arr):
if n == 1:
print(1)
return
if n == 2:
print(3)
return
ans = 3
for i in range(n - 3):
ans += 2
if arr[i] == arr[i + 1]:
continue
if arr[i] > arr[i + 1]:
if arr[i + 1] >= arr[i + 2]:
... | ASSIGN VAR LIST FUNC_DEF IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER RETURN IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER RETURN ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR NUMBER IF VAR B... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | import sys
t = int(input())
def find(lis):
n = len(lis)
for a in range(n - 2):
for b in range(a + 1, n):
for c in range(b + 1, n):
if lis[a] <= lis[b] and lis[b] <= lis[c]:
return False
if lis[a] >= lis[b] and lis[b] >= lis[c]:
... | IMPORT ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF VAR VAR VAR VAR VAR VAR VAR VAR RETURN NUMBER IF VAR VAR VAR VAR VAR VAR VAR VAR RETURN NUMBER RETURN NUM... |
Suppose you have two points $p = (x_p, y_p)$ and $q = (x_q, y_q)$. Let's denote the Manhattan distance between them as $d(p, q) = |x_p - x_q| + |y_p - y_q|$.
Let's say that three points $p$, $q$, $r$ form a bad triple if $d(p, r) = d(p, q) + d(q, r)$.
Let's say that an array $b_1, b_2, \dots, b_m$ is good if it is im... | import sys
input = sys.stdin.readline
def dist(a, b, idxa, idxb):
return abs(a - b) + abs(idxa - idxb)
def solve():
n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(i, n):
if i + 2 <= j:
flag = True
... | IMPORT ASSIGN VAR VAR FUNC_DEF RETURN BIN_OP 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 FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR VAR IF BIN_OP VAR NUMBER VAR ASS... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.