source
stringclasses 4
values | task_type
stringclasses 1
value | in_source_id
stringlengths 0
138
| problem
stringlengths 219
13.2k
| gold_standard_solution
stringlengths 0
413k
| problem_id
stringlengths 5
10
| metadata
dict | verification_info
dict |
|---|---|---|---|---|---|---|---|
apps | verifiable_code | 4407 | Solve the following coding problem using the programming language python:
Polycarp has $n$ coins, the value of the $i$-th coin is $a_i$. It is guaranteed that all the values are integer powers of $2$ (i.e. $a_i = 2^d$ for some non-negative integer number $d$).
Polycarp wants to know answers on $q$ queries. The $j$-th query is described as integer number $b_j$. The answer to the query is the minimum number of coins that is necessary to obtain the value $b_j$ using some subset of coins (Polycarp can use only coins he has). If Polycarp can't obtain the value $b_j$, the answer to the $j$-th query is -1.
The queries are independent (the answer on the query doesn't affect Polycarp's coins).
-----Input-----
The first line of the input contains two integers $n$ and $q$ ($1 \le n, q \le 2 \cdot 10^5$) — the number of coins and the number of queries.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ — values of coins ($1 \le a_i \le 2 \cdot 10^9$). It is guaranteed that all $a_i$ are integer powers of $2$ (i.e. $a_i = 2^d$ for some non-negative integer number $d$).
The next $q$ lines contain one integer each. The $j$-th line contains one integer $b_j$ — the value of the $j$-th query ($1 \le b_j \le 10^9$).
-----Output-----
Print $q$ integers $ans_j$. The $j$-th integer must be equal to the answer on the $j$-th query. If Polycarp can't obtain the value $b_j$ the answer to the $j$-th query is -1.
-----Example-----
Input
5 4
2 4 8 2 4
8
5
14
10
Output
1
-1
3
2
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from collections import Counter
n, q = map(int, input().split())
a = map(int, input().split())
b = [int(input()) for _ in range(q)]
counts = 32 * [0]
for value, count in Counter(a).items():
counts[value.bit_length() - 1] = count
for bj in b:
ans = 0
for i in reversed(range(32)):
count = min(bj >> i, counts[i])
ans += count
bj -= count << i
if bj != 0:
print(-1)
else:
print(ans)
``` | vfc_26335 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1003/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5 4\n2 4 8 2 4\n8\n5\n14\n10\n",
"output": "1\n-1\n3\n2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 3\n1 1 1\n1\n2\n3\n",
"output": "1\n2\n3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 1\n2 4 16 32\n14\n",
"output": "-1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4408 | Solve the following coding problem using the programming language python:
There are $n$ players sitting at the card table. Each player has a favorite number. The favorite number of the $j$-th player is $f_j$.
There are $k \cdot n$ cards on the table. Each card contains a single integer: the $i$-th card contains number $c_i$. Also, you are given a sequence $h_1, h_2, \dots, h_k$. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly $k$ cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals $h_t$ if the player holds $t$ cards containing his favorite number. If a player gets no cards with his favorite number (i.e., $t=0$), his joy level is $0$.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence $h_1, \dots, h_k$ is the same for all the players.
-----Input-----
The first line of input contains two integers $n$ and $k$ ($1 \le n \le 500, 1 \le k \le 10$) — the number of players and the number of cards each player will get.
The second line contains $k \cdot n$ integers $c_1, c_2, \dots, c_{k \cdot n}$ ($1 \le c_i \le 10^5$) — the numbers written on the cards.
The third line contains $n$ integers $f_1, f_2, \dots, f_n$ ($1 \le f_j \le 10^5$) — the favorite numbers of the players.
The fourth line contains $k$ integers $h_1, h_2, \dots, h_k$ ($1 \le h_t \le 10^5$), where $h_t$ is the joy level of a player if he gets exactly $t$ cards with his favorite number written on them. It is guaranteed that the condition $h_{t - 1} < h_t$ holds for each $t \in [2..k]$.
-----Output-----
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
-----Examples-----
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
-----Note-----
In the first example, one possible optimal card distribution is the following: Player $1$ gets cards with numbers $[1, 3, 8]$; Player $2$ gets cards with numbers $[2, 2, 8]$; Player $3$ gets cards with numbers $[2, 2, 8]$; Player $4$ gets cards with numbers $[5, 5, 5]$.
Thus, the answer is $2 + 6 + 6 + 7 = 21$.
In the second example, no player can get a card with his favorite number. Thus, the answer is $0$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from queue import Queue
import sys
import math
import os.path
# CONFIG
sys.setrecursionlimit(10**9)
# LOG
def log(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
# INPUT
def ni():
return list(map(int, input().split()))
def nio(offset):
return [int(x) + offset for x in input().split()]
def nia():
return list(map(int, input().split()))
# CONVERT
def toString(aList, sep=" "):
return sep.join(str(x) for x in aList)
def mapInvertIndex(aList):
return {k: v for v, k in enumerate(aList)}
def countMap(arr):
m = {}
for x in arr:
m[x] = m.get(x,0) + 1
return m
def sortId(arr):
return sorted(list(range(arr)), key=lambda k: arr[k])
# MAIN
n, k = ni()
c = nia()
f = nia()
h = [0] + (nia())
cc = countMap(c)
cf = countMap(f)
n1 = n+1
k1 = k+1
nk1 = n*k+1
dp = [[0]*nk1 for _ in range(n1)]
for ni in range(1,n1):
for ki in range(1,nk1):
mficount = min(k,ki) + 1
for kii in range(mficount):
# log(ni,ki, kii, dp[ni][ki], dp[ni-1][ki-kii] + h[kii])
dp[ni][ki] = max(dp[ni][ki], dp[ni-1][ki-kii] + h[kii])
# log(dp[ni])
# log(n,k)
# log("c", cc)
# log("f", cf)
# log("h", h)
# log(dp)
res = 0
for fk,fv in list(cf.items()):
# log(fk, fv, cc.get(fk,0))
res += dp[fv][cc.get(fk,0)]
print(res)
``` | vfc_26339 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/999/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 3\n1 3 2 8 5 5 8 2 2 8 5 2\n1 2 2 5\n2 6 7\n",
"output": "21\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 3\n9 9 9 9 9 9 9 9 9\n1 2 3\n1 2 3\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 1\n1\n2\n1\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 1\n1\n1\n1\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 1\n1\n1\n100000\n",
"output": "100000\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4410 | Solve the following coding problem using the programming language python:
Polycarp and his friends want to visit a new restaurant. The restaurant has $n$ tables arranged along a straight line. People are already sitting at some tables. The tables are numbered from $1$ to $n$ in the order from left to right. The state of the restaurant is described by a string of length $n$ which contains characters "1" (the table is occupied) and "0" (the table is empty).
Restaurant rules prohibit people to sit at a distance of $k$ or less from each other. That is, if a person sits at the table number $i$, then all tables with numbers from $i-k$ to $i+k$ (except for the $i$-th) should be free. In other words, the absolute difference of the numbers of any two occupied tables must be strictly greater than $k$.
For example, if $n=8$ and $k=2$, then: strings "10010001", "10000010", "00000000", "00100000" satisfy the rules of the restaurant; strings "10100100", "10011001", "11111111" do not satisfy to the rules of the restaurant, since each of them has a pair of "1" with a distance less than or equal to $k=2$.
In particular, if the state of the restaurant is described by a string without "1" or a string with one "1", then the requirement of the restaurant is satisfied.
You are given a binary string $s$ that describes the current state of the restaurant. It is guaranteed that the rules of the restaurant are satisfied for the string $s$.
Find the maximum number of free tables that you can occupy so as not to violate the rules of the restaurant. Formally, what is the maximum number of "0" that can be replaced by "1" such that the requirement will still be satisfied?
For example, if $n=6$, $k=1$, $s=$ "100010", then the answer to the problem will be $1$, since only the table at position $3$ can be occupied such that the rules are still satisfied.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 10^4$) — the number of test cases in the test. Then $t$ test cases follow.
Each test case starts with a line containing two integers $n$ and $k$ ($1 \le k \le n \le 2\cdot 10^5$) — the number of tables in the restaurant and the minimum allowed distance between two people.
The second line of each test case contains a binary string $s$ of length $n$ consisting of "0" and "1" — a description of the free and occupied tables in the restaurant. The given string satisfy to the rules of the restaurant — the difference between indices of any two "1" is more than $k$.
The sum of $n$ for all test cases in one test does not exceed $2\cdot 10^5$.
-----Output-----
For each test case output one integer — the number of tables that you can occupy so as not to violate the rules of the restaurant. If additional tables cannot be taken, then, obviously, you need to output $0$.
-----Example-----
Input
6
6 1
100010
6 2
000000
5 1
10101
3 1
001
2 2
00
1 1
0
Output
1
2
0
1
1
1
-----Note-----
The first test case is explained in the statement.
In the second test case, the answer is $2$, since you can choose the first and the sixth table.
In the third test case, you cannot take any free table without violating the rules of the restaurant.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
INF = 10**20
MOD = 10**9 + 7
I = lambda:list(map(int,input().split()))
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
def solve():
n, k = I()
s = input()
ans = 0
last = -INF
for i in range(n):
if s[i] == '1':
if i - last <= k:
ans -= 1
last = i
count = 0
continue
if i - last > k:
ans += 1
last = i
print(ans)
t, = I()
while t:
t -= 1
solve()
``` | vfc_26347 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1367/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6\n6 1\n100010\n6 2\n000000\n5 1\n10101\n3 1\n001\n2 2\n00\n1 1\n0\n",
"output": "1\n2\n0\n1\n1\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "7\n4 4\n0100\n4 4\n0100\n4 4\n0100\n4 4\n0100\n4 4\n0100\n4 4\n0100\n4 4\n0100\n",
"output": "0\n0\n0\n0\n0\n0\n0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4411 | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions is constraints.
You are given $n$ segments on the coordinate axis $OX$. Segments can intersect, lie inside each other and even coincide. The $i$-th segment is $[l_i; r_i]$ ($l_i \le r_i$) and it covers all integer points $j$ such that $l_i \le j \le r_i$.
The integer point is called bad if it is covered by strictly more than $k$ segments.
Your task is to remove the minimum number of segments so that there are no bad points at all.
-----Input-----
The first line of the input contains two integers $n$ and $k$ ($1 \le k \le n \le 2 \cdot 10^5$) — the number of segments and the maximum number of segments by which each integer point can be covered.
The next $n$ lines contain segments. The $i$-th line contains two integers $l_i$ and $r_i$ ($1 \le l_i \le r_i \le 2 \cdot 10^5$) — the endpoints of the $i$-th segment.
-----Output-----
In the first line print one integer $m$ ($0 \le m \le n$) — the minimum number of segments you need to remove so that there are no bad points.
In the second line print $m$ distinct integers $p_1, p_2, \dots, p_m$ ($1 \le p_i \le n$) — indices of segments you remove in any order. If there are multiple answers, you can print any of them.
-----Examples-----
Input
7 2
11 11
9 11
7 8
8 9
7 8
9 11
7 9
Output
3
4 6 7
Input
5 1
29 30
30 30
29 29
28 30
30 30
Output
3
1 4 5
Input
6 1
2 3
3 3
2 3
2 2
2 3
2 3
Output
4
1 3 5 6
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from operator import itemgetter
import sys
input = sys.stdin.readline
n, m = map(int, input().split())
info = [list(map(int, input().split())) + [i] for i in range(n)]
info = sorted(info, key = itemgetter(1))
max_num = info[-1][1]
N = max_num
INF = 0
LV = (N-1).bit_length()
N0 = 2**LV
data = [0]*(2*N0)
lazy = [0]*(2*N0)
def gindex(l, r):
L = (l + N0) >> 1; R = (r + N0) >> 1
lc = 0 if l & 1 else (L & -L).bit_length()
rc = 0 if r & 1 else (R & -R).bit_length()
for i in range(LV):
if rc <= i:
yield R
if L < R and lc <= i:
yield L
L >>= 1; R >>= 1
def propagates(*ids):
for i in reversed(ids):
v = lazy[i-1]
if not v:
continue
lazy[2*i-1] += v; lazy[2*i] += v
data[2*i-1] += v; data[2*i] += v
lazy[i-1] = 0
def update(l, r, x):
*ids, = gindex(l, r)
propagates(*ids)
L = N0 + l; R = N0 + r
while L < R:
if R & 1:
R -= 1
lazy[R-1] += x; data[R-1] += x
if L & 1:
lazy[L-1] += x; data[L-1] += x
L += 1
L >>= 1; R >>= 1
for i in ids:
data[i-1] = max(data[2*i-1], data[2*i])
def query(l, r):
propagates(*gindex(l, r))
L = N0 + l; R = N0 + r
s = INF
while L < R:
if R & 1:
R -= 1
s = max(s, data[R-1])
if L & 1:
s = max(s, data[L-1])
L += 1
L >>= 1; R >>= 1
return s
ans = []
for i in range(n):
l, r, j = info[i]
r += 1
if query(l, r) < m:
update(l, r, 1)
else:
ans.append(j+1)
print(len(ans))
print(*ans)
``` | vfc_26351 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1249/D2",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7 2\n11 11\n9 11\n7 8\n8 9\n7 8\n9 11\n7 9\n",
"output": "3\n4 6 7 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4412 | Solve the following coding problem using the programming language python:
One important contest will take place on the most famous programming platform (Topforces) very soon!
The authors have a pool of $n$ problems and should choose at most three of them into this contest. The prettiness of the $i$-th problem is $a_i$. The authors have to compose the most pretty contest (in other words, the cumulative prettinesses of chosen problems should be maximum possible).
But there is one important thing in the contest preparation: because of some superstitions of authors, the prettinesses of problems cannot divide each other. In other words, if the prettinesses of chosen problems are $x, y, z$, then $x$ should be divisible by neither $y$, nor $z$, $y$ should be divisible by neither $x$, nor $z$ and $z$ should be divisible by neither $x$, nor $y$. If the prettinesses of chosen problems are $x$ and $y$ then neither $x$ should be divisible by $y$ nor $y$ should be divisible by $x$. Any contest composed from one problem is considered good.
Your task is to find out the maximum possible total prettiness of the contest composed of at most three problems from the given pool.
You have to answer $q$ independent queries.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 2 \cdot 10^5$) — the number of queries.
The first line of the query contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the number of problems.
The second line of the query contains $n$ integers $a_1, a_2, \dots, a_n$ ($2 \le a_i \le 2 \cdot 10^5$), where $a_i$ is the prettiness of the $i$-th problem.
It is guaranteed that the sum of $n$ over all queries does not exceed $2 \cdot 10^5$.
-----Output-----
For each query print one integer — the maximum possible cumulative prettiness of the contest composed of at most three problems from the given pool of problems in the query.
-----Example-----
Input
3
4
5 6 15 30
4
10 6 30 15
3
3 4 6
Output
30
31
10
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
input = sys.stdin.readline
q=int(input())
for testcase in range(q):
n=int(input())
A=sorted(set(map(int,input().split())),reverse=True)
L=len(A)
#print(A)
ANS=A[0]
for i in range(L):
NOW0=A[i]
NOW1=0
flag=0
for j in range(i+1,L):
if NOW0%A[j]!=0:
NOW1=A[j]
ANS=max(ANS,NOW0+NOW1)
for k in range(j+1,L):
if NOW0%A[k]!=0 and NOW1%A[k]!=0:
ANS=max(ANS,NOW0+NOW1+A[k])
#print("!",ANS)
break
break
print(ANS)
``` | vfc_26355 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1183/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n4\n5 6 15 30\n4\n10 6 30 15\n3\n3 4 6\n",
"output": "30\n31\n10\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n5\n30 30 15 10 6\n",
"output": "31\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n5\n6 10 15 30 30\n",
"output": "31\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n37\n166320 83160 41580 33264 27720 23760 20790 18480 16632 15120 13860 11880 11088 10395 9240 8316 7920 7560 6930 6160 5940 5544 5040 4752 4620 4158 3960 3780 3696 3465 3080 3024 2970 2772 2640 29 23\n",
"output": "166372\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4413 | Solve the following coding problem using the programming language python:
You are a coach of a group consisting of $n$ students. The $i$-th student has programming skill $a_i$. All students have distinct programming skills. You want to divide them into teams in such a way that: No two students $i$ and $j$ such that $|a_i - a_j| = 1$ belong to the same team (i.e. skills of each pair of students in the same team have the difference strictly greater than $1$); the number of teams is the minimum possible.
You have to answer $q$ independent queries.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 100$) — the number of queries. Then $q$ queries follow.
The first line of the query contains one integer $n$ ($1 \le n \le 100$) — the number of students in the query. The second line of the query contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 100$, all $a_i$ are distinct), where $a_i$ is the programming skill of the $i$-th student.
-----Output-----
For each query, print the answer on it — the minimum number of teams you can form if no two students $i$ and $j$ such that $|a_i - a_j| = 1$ may belong to the same team (i.e. skills of each pair of students in the same team has the difference strictly greater than $1$)
-----Example-----
Input
4
4
2 10 1 20
2
3 6
5
2 3 4 99 100
1
42
Output
2
1
2
1
-----Note-----
In the first query of the example, there are $n=4$ students with the skills $a=[2, 10, 1, 20]$. There is only one restriction here: the $1$-st and the $3$-th students can't be in the same team (because of $|a_1 - a_3|=|2-1|=1$). It is possible to divide them into $2$ teams: for example, students $1$, $2$ and $4$ are in the first team and the student $3$ in the second team.
In the second query of the example, there are $n=2$ students with the skills $a=[3, 6]$. It is possible to compose just a single team containing both students.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n = int(input())
A = list(map(int, input().split()))
A.sort()
ans = 1
for i in range(n - 1):
if A[i] + 1 == A[i + 1]:
ans = 2
break
print(ans)
``` | vfc_26359 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1249/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n4\n2 10 1 20\n2\n3 6\n5\n2 3 4 99 100\n1\n42\n",
"output": "2\n1\n2\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1\n100\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4414 | Solve the following coding problem using the programming language python:
You have $a$ coins of value $n$ and $b$ coins of value $1$. You always pay in exact change, so you want to know if there exist such $x$ and $y$ that if you take $x$ ($0 \le x \le a$) coins of value $n$ and $y$ ($0 \le y \le b$) coins of value $1$, then the total value of taken coins will be $S$.
You have to answer $q$ independent test cases.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 10^4$) — the number of test cases. Then $q$ test cases follow.
The only line of the test case contains four integers $a$, $b$, $n$ and $S$ ($1 \le a, b, n, S \le 10^9$) — the number of coins of value $n$, the number of coins of value $1$, the value $n$ and the required total value.
-----Output-----
For the $i$-th test case print the answer on it — YES (without quotes) if there exist such $x$ and $y$ that if you take $x$ coins of value $n$ and $y$ coins of value $1$, then the total value of taken coins will be $S$, and NO otherwise.
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES will all be recognized as positive answer).
-----Example-----
Input
4
1 2 3 4
1 2 3 6
5 2 6 27
3 3 5 18
Output
YES
NO
NO
YES
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
q=int(input())
for t in range(q):
a,b,n,s=map(int,input().split())
v=min(a*n,s//n*n)
if s-v>b:
print("NO")
else:
print("YES")
``` | vfc_26363 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1256/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n1 2 3 4\n1 2 3 6\n5 2 6 27\n3 3 5 18\n",
"output": "YES\nNO\nNO\nYES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n87 63 54 9\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n500 1000 600 131\n",
"output": "YES\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4415 | Solve the following coding problem using the programming language python:
Two integer sequences existed initially — one of them was strictly increasing, and the other one — strictly decreasing.
Strictly increasing sequence is a sequence of integers $[x_1 < x_2 < \dots < x_k]$. And strictly decreasing sequence is a sequence of integers $[y_1 > y_2 > \dots > y_l]$. Note that the empty sequence and the sequence consisting of one element can be considered as increasing or decreasing.
They were merged into one sequence $a$. After that sequence $a$ got shuffled. For example, some of the possible resulting sequences $a$ for an increasing sequence $[1, 3, 4]$ and a decreasing sequence $[10, 4, 2]$ are sequences $[1, 2, 3, 4, 4, 10]$ or $[4, 2, 1, 10, 4, 3]$.
This shuffled sequence $a$ is given in the input.
Your task is to find any two suitable initial sequences. One of them should be strictly increasing and the other one — strictly decreasing. Note that the empty sequence and the sequence consisting of one element can be considered as increasing or decreasing.
If there is a contradiction in the input and it is impossible to split the given sequence $a$ to increasing and decreasing sequences, print "NO".
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the number of elements in $a$.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($0 \le a_i \le 2 \cdot 10^5$), where $a_i$ is the $i$-th element of $a$.
-----Output-----
If there is a contradiction in the input and it is impossible to split the given sequence $a$ to increasing and decreasing sequences, print "NO" in the first line.
Otherwise print "YES" in the first line and any two suitable sequences. Note that the empty sequence and the sequence consisting of one element can be considered as increasing or decreasing.
In the second line print $n_i$ — the number of elements in the strictly increasing sequence. $n_i$ can be zero, in this case the increasing sequence is empty.
In the third line print $n_i$ integers $inc_1, inc_2, \dots, inc_{n_i}$ in the increasing order of its values ($inc_1 < inc_2 < \dots < inc_{n_i}$) — the strictly increasing sequence itself. You can keep this line empty if $n_i = 0$ (or just print the empty line).
In the fourth line print $n_d$ — the number of elements in the strictly decreasing sequence. $n_d$ can be zero, in this case the decreasing sequence is empty.
In the fifth line print $n_d$ integers $dec_1, dec_2, \dots, dec_{n_d}$ in the decreasing order of its values ($dec_1 > dec_2 > \dots > dec_{n_d}$) — the strictly decreasing sequence itself. You can keep this line empty if $n_d = 0$ (or just print the empty line).
$n_i + n_d$ should be equal to $n$ and the union of printed sequences should be a permutation of the given sequence (in case of "YES" answer).
-----Examples-----
Input
7
7 2 7 3 3 1 4
Output
YES
2
3 7
5
7 4 3 2 1
Input
5
4 3 1 5 3
Output
YES
1
3
4
5 4 3 1
Input
5
1 1 2 1 2
Output
NO
Input
5
0 1 2 3 4
Output
YES
0
5
4 3 2 1 0
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n = int(input())
a = list(map(int, input().split()))
a.sort()
inc = list()
dec = list()
for x in a:
if inc and inc[-1] == x:
if dec and dec[-1] == x:
print('NO')
return
dec.append(x)
else:
inc.append(x)
print('YES')
print(len(inc))
for x in inc:
print(x, end=' ')
print()
print(len(dec))
for x in reversed(dec):
print(x, end=' ')
print()
``` | vfc_26367 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1144/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7\n7 2 7 3 3 1 4\n",
"output": "YES\n2\n3 7 \n5\n7 4 3 2 1 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n4 3 1 5 3\n",
"output": "YES\n1\n3 \n4\n5 4 3 1 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n1 1 2 1 2\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n0 1 2 3 4\n",
"output": "YES\n0\n\n5\n4 3 2 1 0 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1337\n",
"output": "YES\n0\n\n1\n1337 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "7\n1 2 3 3 3 3 4\n",
"output": "NO\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4416 | Solve the following coding problem using the programming language python:
Easy and hard versions are actually different problems, so read statements of both problems completely and carefully.
Summer vacation has started so Alice and Bob want to play and joy, but... Their mom doesn't think so. She says that they have to read some amount of books before all entertainments. Alice and Bob will read each book together to end this exercise faster.
There are $n$ books in the family library. The $i$-th book is described by three integers: $t_i$ — the amount of time Alice and Bob need to spend to read it, $a_i$ (equals $1$ if Alice likes the $i$-th book and $0$ if not), and $b_i$ (equals $1$ if Bob likes the $i$-th book and $0$ if not).
So they need to choose some books from the given $n$ books in such a way that:
Alice likes at least $k$ books from the chosen set and Bob likes at least $k$ books from the chosen set; the total reading time of these books is minimized (they are children and want to play and joy as soon a possible).
The set they choose is the same for both Alice an Bob (it's shared between them) and they read all books together, so the total reading time is the sum of $t_i$ over all books that are in the chosen set.
Your task is to help them and find any suitable set of books or determine that it is impossible to find such a set.
-----Input-----
The first line of the input contains two integers $n$ and $k$ ($1 \le k \le n \le 2 \cdot 10^5$).
The next $n$ lines contain descriptions of books, one description per line: the $i$-th line contains three integers $t_i$, $a_i$ and $b_i$ ($1 \le t_i \le 10^4$, $0 \le a_i, b_i \le 1$), where:
$t_i$ — the amount of time required for reading the $i$-th book; $a_i$ equals $1$ if Alice likes the $i$-th book and $0$ otherwise; $b_i$ equals $1$ if Bob likes the $i$-th book and $0$ otherwise.
-----Output-----
If there is no solution, print only one integer -1. Otherwise print one integer $T$ — the minimum total reading time of the suitable set of books.
-----Examples-----
Input
8 4
7 1 1
2 1 1
4 0 1
8 1 1
1 0 1
1 1 1
1 0 1
3 0 0
Output
18
Input
5 2
6 0 0
9 0 0
1 0 1
2 1 1
5 1 0
Output
8
Input
5 3
3 0 0
2 1 0
3 1 0
5 0 1
3 0 1
Output
-1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from sys import stdin
n,k = list(map(int, stdin.readline().strip().split(' ')))
AB = []
A = []
B = []
for i in range(n):
t,a,b = list(map(int, stdin.readline().strip().split(' ')))
if a == 1 and b == 1:
AB.append(t)
elif a == 1:
A.append(t)
elif b == 1:
B.append(t)
AB.sort()
A.sort()
B.sort()
ans = 0
abi = 0
ai = 0
bi = 0
isPossible = True
for i in range(k):
if abi == len(AB) and (ai == len(A) or bi == len(B)):
isPossible = False
break
if abi == len(AB):
ans += (A[ai] + B[bi])
ai += 1
bi += 1
continue
if ai == len(A) or bi == len(B):
ans += AB[abi]
abi += 1
continue
if A[ai] + B[bi] <= AB[abi]:
ans += (A[ai] + B[bi])
ai += 1
bi += 1
continue
ans += AB[abi]
abi += 1
continue
if isPossible:
print(ans)
else:
print(-1)
``` | vfc_26371 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1374/E1",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "8 4\n7 1 1\n2 1 1\n4 0 1\n8 1 1\n1 0 1\n1 1 1\n1 0 1\n3 0 0\n",
"output": "18\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4417 | Solve the following coding problem using the programming language python:
There are $n$ products in the shop. The price of the $i$-th product is $a_i$. The owner of the shop wants to equalize the prices of all products. However, he wants to change prices smoothly.
In fact, the owner of the shop can change the price of some product $i$ in such a way that the difference between the old price of this product $a_i$ and the new price $b_i$ is at most $k$. In other words, the condition $|a_i - b_i| \le k$ should be satisfied ($|x|$ is the absolute value of $x$).
He can change the price for each product not more than once. Note that he can leave the old prices for some products. The new price $b_i$ of each product $i$ should be positive (i.e. $b_i > 0$ should be satisfied for all $i$ from $1$ to $n$).
Your task is to find out the maximum possible equal price $B$ of all productts with the restriction that for all products the condiion $|a_i - B| \le k$ should be satisfied (where $a_i$ is the old price of the product and $B$ is the same new price of all products) or report that it is impossible to find such price $B$.
Note that the chosen price $B$ should be integer.
You should answer $q$ independent queries.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 100$) — the number of queries. Each query is presented by two lines.
The first line of the query contains two integers $n$ and $k$ ($1 \le n \le 100, 1 \le k \le 10^8$) — the number of products and the value $k$. The second line of the query contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^8$), where $a_i$ is the price of the $i$-th product.
-----Output-----
Print $q$ integers, where the $i$-th integer is the answer $B$ on the $i$-th query.
If it is impossible to equalize prices of all given products with restriction that for all products the condition $|a_i - B| \le k$ should be satisfied (where $a_i$ is the old price of the product and $B$ is the new equal price of all products), print -1. Otherwise print the maximum possible equal price of all products.
-----Example-----
Input
4
5 1
1 1 2 3 1
4 2
6 4 8 5
2 2
1 6
3 5
5 2 5
Output
2
6
-1
7
-----Note-----
In the first example query you can choose the price $B=2$. It is easy to see that the difference between each old price and each new price $B=2$ is no more than $1$.
In the second example query you can choose the price $B=6$ and then all the differences between old and new price $B=6$ will be no more than $2$.
In the third example query you cannot choose any suitable price $B$. For any value $B$ at least one condition out of two will be violated: $|1-B| \le 2$, $|6-B| \le 2$.
In the fourth example query all values $B$ between $1$ and $7$ are valid. But the maximum is $7$, so it's the answer.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for ei in range(int(input())):
n, k = map(int, input().split())
A = list(map(int, input().split()))
ans = min(A) + k
for i in A:
if ans != -1 and abs(ans - i) > k:
ans = -1
print(ans)
``` | vfc_26375 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1183/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n5 1\n1 1 2 3 1\n4 2\n6 4 8 5\n2 2\n1 6\n3 5\n5 2 5\n",
"output": "2\n6\n-1\n7\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n2 3\n5 15\n",
"output": "-1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4418 | Solve the following coding problem using the programming language python:
You are given an array $a$ consisting of $n$ integers. Each $a_i$ is one of the six following numbers: $4, 8, 15, 16, 23, 42$.
Your task is to remove the minimum number of elements to make this array good.
An array of length $k$ is called good if $k$ is divisible by $6$ and it is possible to split it into $\frac{k}{6}$ subsequences $4, 8, 15, 16, 23, 42$.
Examples of good arrays: $[4, 8, 15, 16, 23, 42]$ (the whole array is a required sequence); $[4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42]$ (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements); $[]$ (the empty array is good).
Examples of bad arrays: $[4, 8, 15, 16, 42, 23]$ (the order of elements should be exactly $4, 8, 15, 16, 23, 42$); $[4, 8, 15, 16, 23, 42, 4]$ (the length of the array is not divisible by $6$); $[4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23]$ (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 5 \cdot 10^5$) — the number of elements in $a$.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ (each $a_i$ is one of the following numbers: $4, 8, 15, 16, 23, 42$), where $a_i$ is the $i$-th element of $a$.
-----Output-----
Print one integer — the minimum number of elements you have to remove to obtain a good array.
-----Examples-----
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
#!/usr/bin/env python
n = int(input())
a = list(map(int, input().split()))
k = [None, 4, 8, 15, 16, 23, 42]
s = [n, 0, 0, 0, 0, 0, 0]
for ai in a:
for i in range(6, 0, -1):
if ai == k[i] and s[i - 1] > 0:
s[i] += 1; s[i - 1] -= 1
break
print(n - 6 * s[-1])
``` | vfc_26379 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1176/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n4 8 15 16 23\n",
"output": "5\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "12\n4 8 4 15 16 8 23 15 16 42 23 42\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "15\n4 8 4 8 15 16 8 16 23 15 16 4 42 23 42\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n4\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n42\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "100\n4 42 23 23 8 42 16 23 42 16 42 8 4 23 4 4 23 42 16 42 23 23 23 42 4 42 8 8 16 23 15 23 16 4 42 15 15 23 16 15 16 4 4 15 23 42 42 15 8 23 8 23 4 15 16 15 42 8 23 16 15 42 23 8 4 16 15 16 23 16 16 4 23 16 8 23 16 15 23 4 4 8 15 4 4 15 8 23 23 4 4 8 8 4 42 15 4 4 42 16\n",
"output": "64\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4419 | Solve the following coding problem using the programming language python:
You are given two integers $a$ and $b$.
In one move, you can choose some integer $k$ from $1$ to $10$ and add it to $a$ or subtract it from $a$. In other words, you choose an integer $k \in [1; 10]$ and perform $a := a + k$ or $a := a - k$. You may use different values of $k$ in different moves.
Your task is to find the minimum number of moves required to obtain $b$ from $a$.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 2 \cdot 10^4$) — the number of test cases. Then $t$ test cases follow.
The only line of the test case contains two integers $a$ and $b$ ($1 \le a, b \le 10^9$).
-----Output-----
For each test case, print the answer: the minimum number of moves required to obtain $b$ from $a$.
-----Example-----
Input
6
5 5
13 42
18 4
1337 420
123456789 1000000000
100500 9000
Output
0
3
2
92
87654322
9150
-----Note-----
In the first test case of the example, you don't need to do anything.
In the second test case of the example, the following sequence of moves can be applied: $13 \rightarrow 23 \rightarrow 32 \rightarrow 42$ (add $10$, add $9$, add $10$).
In the third test case of the example, the following sequence of moves can be applied: $18 \rightarrow 10 \rightarrow 4$ (subtract $8$, subtract $6$).
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
a,b=map(int,input().split())
print((abs(a-b)+9)//10)
``` | vfc_26383 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1409/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6\n5 5\n13 42\n18 4\n1337 420\n123456789 1000000000\n100500 9000\n",
"output": "0\n3\n2\n92\n87654322\n9150\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n5 5\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "11\n5 5\n13 42\n18 4\n1337 420\n123456789 1000000000\n100500 9000\n5 5\n13 42\n18 4\n1337 420\n123456789 1000000000\n",
"output": "0\n3\n2\n92\n87654322\n9150\n0\n3\n2\n92\n87654322\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n5 5\n5 5\n",
"output": "0\n0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n5 5\n5 5\n5 5\n5 5\n",
"output": "0\n0\n0\n0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4420 | Solve the following coding problem using the programming language python:
You are given three integers $x, y$ and $n$. Your task is to find the maximum integer $k$ such that $0 \le k \le n$ that $k \bmod x = y$, where $\bmod$ is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given $x, y$ and $n$ you need to find the maximum possible integer from $0$ to $n$ that has the remainder $y$ modulo $x$.
You have to answer $t$ independent test cases. It is guaranteed that such $k$ exists for each test case.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 5 \cdot 10^4$) — the number of test cases. The next $t$ lines contain test cases.
The only line of the test case contains three integers $x, y$ and $n$ ($2 \le x \le 10^9;~ 0 \le y < x;~ y \le n \le 10^9$).
It can be shown that such $k$ always exists under the given constraints.
-----Output-----
For each test case, print the answer — maximum non-negative integer $k$ such that $0 \le k \le n$ and $k \bmod x = y$. It is guaranteed that the answer always exists.
-----Example-----
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
-----Note-----
In the first test case of the example, the answer is $12339 = 7 \cdot 1762 + 5$ (thus, $12339 \bmod 7 = 5$). It is obvious that there is no greater integer not exceeding $12345$ which has the remainder $5$ modulo $7$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
ntest = int(input())
for testcase in range(ntest):
x, y, n = list(map(int, input().split()))
t = (n - y) // x * x + y
print(t)
``` | vfc_26387 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1374/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7\n7 5 12345\n5 0 4\n10 5 15\n17 8 54321\n499999993 9 1000000000\n10 5 187\n2 0 999999999\n",
"output": "12339\n0\n15\n54306\n999999995\n185\n999999998\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4421 | Solve the following coding problem using the programming language python:
International Women's Day is coming soon! Polycarp is preparing for the holiday.
There are $n$ candy boxes in the shop for sale. The $i$-th box contains $d_i$ candies.
Polycarp wants to prepare the maximum number of gifts for $k$ girls. Each gift will consist of exactly two boxes. The girls should be able to share each gift equally, so the total amount of candies in a gift (in a pair of boxes) should be divisible by $k$. In other words, two boxes $i$ and $j$ ($i \ne j$) can be combined as a gift if $d_i + d_j$ is divisible by $k$.
How many boxes will Polycarp be able to give? Of course, each box can be a part of no more than one gift. Polycarp cannot use boxes "partially" or redistribute candies between them.
-----Input-----
The first line of the input contains two integers $n$ and $k$ ($1 \le n \le 2 \cdot 10^5, 1 \le k \le 100$) — the number the boxes and the number the girls.
The second line of the input contains $n$ integers $d_1, d_2, \dots, d_n$ ($1 \le d_i \le 10^9$), where $d_i$ is the number of candies in the $i$-th box.
-----Output-----
Print one integer — the maximum number of the boxes Polycarp can give as gifts.
-----Examples-----
Input
7 2
1 2 2 3 2 4 10
Output
6
Input
8 2
1 2 2 3 2 4 6 10
Output
8
Input
7 3
1 2 2 3 2 4 5
Output
4
-----Note-----
In the first example Polycarp can give the following pairs of boxes (pairs are presented by indices of corresponding boxes): $(2, 3)$; $(5, 6)$; $(1, 4)$.
So the answer is $6$.
In the second example Polycarp can give the following pairs of boxes (pairs are presented by indices of corresponding boxes): $(6, 8)$; $(2, 3)$; $(1, 4)$; $(5, 7)$.
So the answer is $8$.
In the third example Polycarp can give the following pairs of boxes (pairs are presented by indices of corresponding boxes): $(1, 2)$; $(6, 7)$.
So the answer is $4$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n, k = map(int, input().split())
D = list(map(int, input().split()))
z = {i: 0 for i in range(k)}
for i in range(n):
z[D[i] % k] += 1
cnt = z[0] // 2
for q in range(1, k // 2 + k % 2):
cnt += min(z[q], z[k - q])
if k % 2 == 0:
cnt += z[k // 2] // 2
print(cnt * 2)
``` | vfc_26391 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1133/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7 2\n1 2 2 3 2 4 10\n",
"output": "6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "8 2\n1 2 2 3 2 4 6 10\n",
"output": "8\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4428 | Solve the following coding problem using the programming language python:
You are given an array $d_1, d_2, \dots, d_n$ consisting of $n$ integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be $sum_1$, the sum of elements of the second part be $sum_2$ and the sum of elements of the third part be $sum_3$. Among all possible ways to split the array you have to choose a way such that $sum_1 = sum_3$ and $sum_1$ is maximum possible.
More formally, if the first part of the array contains $a$ elements, the second part of the array contains $b$ elements and the third part contains $c$ elements, then:
$$sum_1 = \sum\limits_{1 \le i \le a}d_i,$$ $$sum_2 = \sum\limits_{a + 1 \le i \le a + b}d_i,$$ $$sum_3 = \sum\limits_{a + b + 1 \le i \le a + b + c}d_i.$$
The sum of an empty array is $0$.
Your task is to find a way to split the array such that $sum_1 = sum_3$ and $sum_1$ is maximum possible.
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the number of elements in the array $d$.
The second line of the input contains $n$ integers $d_1, d_2, \dots, d_n$ ($1 \le d_i \le 10^9$) — the elements of the array $d$.
-----Output-----
Print a single integer — the maximum possible value of $sum_1$, considering that the condition $sum_1 = sum_3$ must be met.
Obviously, at least one valid way to split the array exists (use $a=c=0$ and $b=n$).
-----Examples-----
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
-----Note-----
In the first example there is only one possible splitting which maximizes $sum_1$: $[1, 3, 1], [~], [1, 4]$.
In the second example the only way to have $sum_1=4$ is: $[1, 3], [2, 1], [4]$.
In the third example there is only one way to split the array: $[~], [4, 1, 2], [~]$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
input()
num = list(map(int, input().split()))
maxn = 0
l, r = 0, len(num)-1
j1, j2 = num[l], num[r]
while l < r:
if j1 == j2:
maxn = max(j1, maxn)
l += 1
j1 += num[l]
elif j1 < j2:
l += 1
j1 += num[l]
else:
r -= 1
j2 += num[r]
print(maxn)
``` | vfc_26419 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1006/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n1 3 1 1 4\n",
"output": "5\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n1 3 2 1 4\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n4 1 2\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1000000000\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1 1\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n1 3 5 4 5\n",
"output": "9\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4429 | Solve the following coding problem using the programming language python:
You are given three positive (i.e. strictly greater than zero) integers $x$, $y$ and $z$.
Your task is to find positive integers $a$, $b$ and $c$ such that $x = \max(a, b)$, $y = \max(a, c)$ and $z = \max(b, c)$, or determine that it is impossible to find such $a$, $b$ and $c$.
You have to answer $t$ independent test cases. Print required $a$, $b$ and $c$ in any (arbitrary) order.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 2 \cdot 10^4$) — the number of test cases. Then $t$ test cases follow.
The only line of the test case contains three integers $x$, $y$, and $z$ ($1 \le x, y, z \le 10^9$).
-----Output-----
For each test case, print the answer: "NO" in the only line of the output if a solution doesn't exist; or "YES" in the first line and any valid triple of positive integers $a$, $b$ and $c$ ($1 \le a, b, c \le 10^9$) in the second line. You can print $a$, $b$ and $c$ in any order.
-----Example-----
Input
5
3 2 3
100 100 100
50 49 49
10 30 20
1 1000000000 1000000000
Output
YES
3 2 1
YES
100 100 100
NO
NO
YES
1 1 1000000000
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for testcase in range(int(input())):
vals = list(map(int, input().split()))
ans = None
for a in vals:
for b in vals:
for c in vals:
if max(a, b) == vals[0] and max(a, c) == vals[1] and max(b, c) == vals[2]:
ans = [a, b, c]
if ans is None:
print("NO")
else:
print("YES")
print(*ans)
``` | vfc_26423 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1385/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n3 2 3\n100 100 100\n50 49 49\n10 30 20\n1 1000000000 1000000000\n",
"output": "YES\n2 2 3\nYES\n100 100 100\nNO\nNO\nYES\n1 1 1000000000\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n5 7 7\n6 7 3\n",
"output": "YES\n5 5 7\nNO\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4430 | Solve the following coding problem using the programming language python:
Maksim has $n$ objects and $m$ boxes, each box has size exactly $k$. Objects are numbered from $1$ to $n$ in order from left to right, the size of the $i$-th object is $a_i$.
Maksim wants to pack his objects into the boxes and he will pack objects by the following algorithm: he takes one of the empty boxes he has, goes from left to right through the objects, and if the $i$-th object fits in the current box (the remaining size of the box is greater than or equal to $a_i$), he puts it in the box, and the remaining size of the box decreases by $a_i$. Otherwise he takes the new empty box and continues the process above. If he has no empty boxes and there is at least one object not in some box then Maksim cannot pack the chosen set of objects.
Maksim wants to know the maximum number of objects he can pack by the algorithm above. To reach this target, he will throw out the leftmost object from the set until the remaining set of objects can be packed in boxes he has. Your task is to say the maximum number of objects Maksim can pack in boxes he has.
Each time when Maksim tries to pack the objects into the boxes, he will make empty all the boxes he has before do it (and the relative order of the remaining set of objects will not change).
-----Input-----
The first line of the input contains three integers $n$, $m$, $k$ ($1 \le n, m \le 2 \cdot 10^5$, $1 \le k \le 10^9$) — the number of objects, the number of boxes and the size of each box.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le k$), where $a_i$ is the size of the $i$-th object.
-----Output-----
Print the maximum number of objects Maksim can pack using the algorithm described in the problem statement.
-----Examples-----
Input
5 2 6
5 2 1 4 2
Output
4
Input
5 1 4
4 2 3 4 1
Output
1
Input
5 3 3
1 2 3 1 1
Output
5
-----Note-----
In the first example Maksim can pack only $4$ objects. Firstly, he tries to pack all the $5$ objects. Distribution of objects will be $[5], [2, 1]$. Maxim cannot pack the next object in the second box and he has no more empty boxes at all. Next he will throw out the first object and the objects distribution will be $[2, 1], [4, 2]$. So the answer is $4$.
In the second example it is obvious that Maksim cannot pack all the objects starting from first, second, third and fourth (in all these cases the distribution of objects is $[4]$), but he can pack the last object ($[1]$).
In the third example Maksim can pack all the objects he has. The distribution will be $[1, 2], [3], [1, 1]$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n, m, k = [int(_) for _ in input().split()]
a = [int(_) for _ in input().split()]
b = k
count = 0
for obj in a[::-1]:
if obj > k:
break
if obj > b:
if m > 1:
m -= 1
b = k - obj
count += 1
else:
break
else:
b -= obj
count += 1
print(count)
``` | vfc_26427 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1066/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5 2 6\n5 2 1 4 2\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 1 4\n4 2 3 4 1\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4431 | Solve the following coding problem using the programming language python:
Recently, Norge found a string $s = s_1 s_2 \ldots s_n$ consisting of $n$ lowercase Latin letters. As an exercise to improve his typing speed, he decided to type all substrings of the string $s$. Yes, all $\frac{n (n + 1)}{2}$ of them!
A substring of $s$ is a non-empty string $x = s[a \ldots b] = s_{a} s_{a + 1} \ldots s_{b}$ ($1 \leq a \leq b \leq n$). For example, "auto" and "ton" are substrings of "automaton".
Shortly after the start of the exercise, Norge realized that his keyboard was broken, namely, he could use only $k$ Latin letters $c_1, c_2, \ldots, c_k$ out of $26$.
After that, Norge became interested in how many substrings of the string $s$ he could still type using his broken keyboard. Help him to find this number.
-----Input-----
The first line contains two space-separated integers $n$ and $k$ ($1 \leq n \leq 2 \cdot 10^5$, $1 \leq k \leq 26$) — the length of the string $s$ and the number of Latin letters still available on the keyboard.
The second line contains the string $s$ consisting of exactly $n$ lowercase Latin letters.
The third line contains $k$ space-separated distinct lowercase Latin letters $c_1, c_2, \ldots, c_k$ — the letters still available on the keyboard.
-----Output-----
Print a single number — the number of substrings of $s$ that can be typed using only available letters $c_1, c_2, \ldots, c_k$.
-----Examples-----
Input
7 2
abacaba
a b
Output
12
Input
10 3
sadfaasdda
f a d
Output
21
Input
7 1
aaaaaaa
b
Output
0
-----Note-----
In the first example Norge can print substrings $s[1\ldots2]$, $s[2\ldots3]$, $s[1\ldots3]$, $s[1\ldots1]$, $s[2\ldots2]$, $s[3\ldots3]$, $s[5\ldots6]$, $s[6\ldots7]$, $s[5\ldots7]$, $s[5\ldots5]$, $s[6\ldots6]$, $s[7\ldots7]$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n, k = map(int, input().split())
s = set()
st = input()
inp = input().split()
for x in inp:
s.add(x)
current, ans = 0, 0
for x in st:
if x in s:
current += 1
else:
ans += (current * (current + 1)) // 2
current = 0
ans += (current * (current + 1)) // 2
print(ans)
``` | vfc_26431 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1272/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7 2\nabacaba\na b\n",
"output": "12\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10 3\nsadfaasdda\nf a d\n",
"output": "21\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4433 | Solve the following coding problem using the programming language python:
You are given an undirected unweighted connected graph consisting of $n$ vertices and $m$ edges. It is guaranteed that there are no self-loops or multiple edges in the given graph.
Your task is to find any spanning tree of this graph such that the maximum degree over all vertices is maximum possible. Recall that the degree of a vertex is the number of edges incident to it.
-----Input-----
The first line contains two integers $n$ and $m$ ($2 \le n \le 2 \cdot 10^5$, $n - 1 \le m \le min(2 \cdot 10^5, \frac{n(n-1)}{2})$) — the number of vertices and edges, respectively.
The following $m$ lines denote edges: edge $i$ is represented by a pair of integers $v_i$, $u_i$ ($1 \le v_i, u_i \le n$, $u_i \ne v_i$), which are the indices of vertices connected by the edge. There are no loops or multiple edges in the given graph, i. e. for each pair ($v_i, u_i$) there are no other pairs ($v_i, u_i$) or ($u_i, v_i$) in the list of edges, and for each pair $(v_i, u_i)$ the condition $v_i \ne u_i$ is satisfied.
-----Output-----
Print $n-1$ lines describing the edges of a spanning tree such that the maximum degree over all vertices is maximum possible. Make sure that the edges of the printed spanning tree form some subset of the input edges (order doesn't matter and edge $(v, u)$ is considered the same as the edge $(u, v)$).
If there are multiple possible answers, print any of them.
-----Examples-----
Input
5 5
1 2
2 3
3 5
4 3
1 5
Output
3 5
2 1
3 2
3 4
Input
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
4 1
1 2
1 3
Input
8 9
1 2
2 3
2 5
1 6
3 4
6 5
4 5
2 7
5 8
Output
3 2
2 5
8 5
6 1
2 7
1 2
3 4
-----Note-----
Picture corresponding to the first example: [Image]
In this example the number of edges of spanning tree incident to the vertex $3$ is $3$. It is the maximum degree over all vertices of the spanning tree. It is easy to see that we cannot obtain a better answer.
Picture corresponding to the second example: [Image]
In this example the number of edges of spanning tree incident to the vertex $1$ is $3$. It is the maximum degree over all vertices of the spanning tree. It is easy to see that we cannot obtain a better answer.
Picture corresponding to the third example: [Image]
In this example the number of edges of spanning tree incident to the vertex $2$ is $4$. It is the maximum degree over all vertices of the spanning tree. It is easy to see that we cannot obtain a better answer. But because this example is symmetric, we can choose almost the same spanning tree but with vertex $5$ instead of $2$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n, m = map(int, input().split())
g = []
for i in range(n):
g.append([])
for i in range(m):
u, v = map(int, input().split())
u-=1
v-=1
g[u]+=[v]
g[v]+=[u]
start = max(range(n), key=lambda i: len(g[i]))
edges = []
vis = [False] * n
q = [start]
vis[start] = True
while q:
u = q.pop(0)
for v in g[u]:
if vis[v]:
continue
vis[v] = True
edges.append((u, v))
q.append(v)
for u, v in edges:
print(u+1, v+1)
``` | vfc_26439 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1133/F1",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5 5\n1 2\n2 3\n3 5\n4 3\n1 5\n",
"output": "4 3\n3 5\n2 3\n1 2\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4434 | Solve the following coding problem using the programming language python:
You are given a board of size $n \times n$, where $n$ is odd (not divisible by $2$). Initially, each cell of the board contains one figure.
In one move, you can select exactly one figure presented in some cell and move it to one of the cells sharing a side or a corner with the current cell, i.e. from the cell $(i, j)$ you can move the figure to cells: $(i - 1, j - 1)$; $(i - 1, j)$; $(i - 1, j + 1)$; $(i, j - 1)$; $(i, j + 1)$; $(i + 1, j - 1)$; $(i + 1, j)$; $(i + 1, j + 1)$;
Of course, you can not move figures to cells out of the board. It is allowed that after a move there will be several figures in one cell.
Your task is to find the minimum number of moves needed to get all the figures into one cell (i.e. $n^2-1$ cells should contain $0$ figures and one cell should contain $n^2$ figures).
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 200$) — the number of test cases. Then $t$ test cases follow.
The only line of the test case contains one integer $n$ ($1 \le n < 5 \cdot 10^5$) — the size of the board. It is guaranteed that $n$ is odd (not divisible by $2$).
It is guaranteed that the sum of $n$ over all test cases does not exceed $5 \cdot 10^5$ ($\sum n \le 5 \cdot 10^5$).
-----Output-----
For each test case print the answer — the minimum number of moves needed to get all the figures into one cell.
-----Example-----
Input
3
1
5
499993
Output
0
40
41664916690999888
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
a=int(input())
for ufui in range(a):
val=int(input())
num=val//2 + 1
count=0
for i in range(num):
count=count+i*((2*i+1)**2 - (2*i-1)**2)
print (count)
``` | vfc_26443 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1353/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n1\n5\n499993\n",
"output": "0\n40\n41664916690999888\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n499999\n",
"output": "41666416667000000\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n69791\n",
"output": "113312287936960\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n5\n3005\n3005\n",
"output": "40\n9045074040\n9045074040\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4435 | Solve the following coding problem using the programming language python:
You are given an array $a$ consisting of $n$ integers. In one move, you can jump from the position $i$ to the position $i - a_i$ (if $1 \le i - a_i$) or to the position $i + a_i$ (if $i + a_i \le n$).
For each position $i$ from $1$ to $n$ you want to know the minimum the number of moves required to reach any position $j$ such that $a_j$ has the opposite parity from $a_i$ (i.e. if $a_i$ is odd then $a_j$ has to be even and vice versa).
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the number of elements in $a$.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le n$), where $a_i$ is the $i$-th element of $a$.
-----Output-----
Print $n$ integers $d_1, d_2, \dots, d_n$, where $d_i$ is the minimum the number of moves required to reach any position $j$ such that $a_j$ has the opposite parity from $a_i$ (i.e. if $a_i$ is odd then $a_j$ has to be even and vice versa) or -1 if it is impossible to reach such a position.
-----Example-----
Input
10
4 5 7 6 7 5 4 4 6 4
Output
1 1 1 2 -1 1 1 3 1 1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from heapq import heappush, heappop
n = int(input())
a = list(map(int, input().split()))
edge = [[] for _ in range(n)]
rev = [[] for _ in range(n)]
inf = 10**9
cost = [inf]*n
hq = []
for i, x in enumerate(a):
if i+x < n:
edge[i].append(i+x)
rev[i+x].append(i)
if (a[i] ^ a[i+x]) & 1:
cost[i] = 1
if i-x >= 0:
edge[i].append(i-x)
rev[i-x].append(i)
if (a[i] ^ a[i-x]) & 1:
cost[i] = 1
if cost[i] == 1:
hq.append((1, i))
while hq:
c, v = heappop(hq)
if cost[v] < c:
continue
c += 1
for dest in rev[v]:
if cost[dest] > c:
cost[dest] = c
heappush(hq, (c, dest))
for i in range(n):
if cost[i] == inf:
cost[i] = -1
print(*cost)
``` | vfc_26447 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1272/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "10\n4 5 7 6 7 5 4 4 6 4\n",
"output": "1 1 1 2 -1 1 1 3 1 1 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4436 | Solve the following coding problem using the programming language python:
You are given one integer number $n$. Find three distinct integers $a, b, c$ such that $2 \le a, b, c$ and $a \cdot b \cdot c = n$ or say that it is impossible to do it.
If there are several answers, you can print any.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 100$) — the number of test cases.
The next $n$ lines describe test cases. The $i$-th test case is given on a new line as one integer $n$ ($2 \le n \le 10^9$).
-----Output-----
For each test case, print the answer on it. Print "NO" if it is impossible to represent $n$ as $a \cdot b \cdot c$ for some distinct integers $a, b, c$ such that $2 \le a, b, c$.
Otherwise, print "YES" and any possible such representation.
-----Example-----
Input
5
64
32
97
2
12345
Output
YES
2 4 8
NO
NO
NO
YES
3 5 823
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
#-------------Program--------------
#----Kuzlyaev-Nikita-Codeforces----
#-------------Round615-------------
#----------------------------------
t=int(input())
for i in range(t):
n=int(input())
a=[]
for i in range(2,int(n**0.5)+2):
if len(a)==2:
a.append(n)
break
if n%i==0:
a.append(i)
n//=i
a=list(set(a))
if len(a)==3 and a.count(1)==0:
print('YES')
a.sort()
print(a[0],a[1],a[2])
else:
print('NO')
``` | vfc_26451 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1294/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n64\n32\n97\n2\n12345\n",
"output": "YES\n2 4 8 \nNO\nNO\nNO\nYES\n3 5 823 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4437 | Solve the following coding problem using the programming language python:
Nikolay got a string $s$ of even length $n$, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from $1$ to $n$.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string $s$ of length $l$ ($1 \le l \le n$) is a string $s[1..l]$.
For example, for the string $s=$"abba" there are two prefixes of the even length. The first is $s[1\dots2]=$"ab" and the second $s[1\dots4]=$"abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string $s$ to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
-----Input-----
The first line of the input contains one even integer $n$ $(2 \le n \le 2\cdot10^{5})$ — the length of string $s$.
The second line of the input contains the string $s$ of length $n$, which consists only of lowercase Latin letters 'a' and 'b'.
-----Output-----
In the first line print the minimum number of operations Nikolay has to perform with the string $s$ to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
-----Examples-----
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
-----Note-----
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
input = sys.stdin.readline
n=int(input())
s=list(input().strip())
ANS=0
for i in range(0,n,2):
if s[i]==s[i+1]:
ANS+=1
if s[i]=="a":
s[i]="b"
else:
s[i]="a"
print(ANS)
print("".join(s))
``` | vfc_26455 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1216/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\nbbbb\n",
"output": "2\nabab\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\nababab\n",
"output": "0\nababab\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\naa\n",
"output": "1\nba\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\nbbbbba\n",
"output": "2\nababba\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "8\nbbbabbba\n",
"output": "2\nabbaabba\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "8\nbbabbbaa\n",
"output": "3\nabababba\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4438 | Solve the following coding problem using the programming language python:
Maksim walks on a Cartesian plane. Initially, he stands at the point $(0, 0)$ and in one move he can go to any of four adjacent points (left, right, up, down). For example, if Maksim is currently at the point $(0, 0)$, he can go to any of the following points in one move: $(1, 0)$; $(0, 1)$; $(-1, 0)$; $(0, -1)$.
There are also $n$ distinct key points at this plane. The $i$-th point is $p_i = (x_i, y_i)$. It is guaranteed that $0 \le x_i$ and $0 \le y_i$ and there is no key point $(0, 0)$.
Let the first level points be such points that $max(x_i, y_i) = 1$, the second level points be such points that $max(x_i, y_i) = 2$ and so on. Maksim wants to visit all the key points. But he shouldn't visit points of level $i + 1$ if he does not visit all the points of level $i$. He starts visiting the points from the minimum level of point from the given set.
The distance between two points $(x_1, y_1)$ and $(x_2, y_2)$ is $|x_1 - x_2| + |y_1 - y_2|$ where $|v|$ is the absolute value of $v$.
Maksim wants to visit all the key points in such a way that the total distance he walks will be minimum possible. Your task is to find this distance.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the number of key points.
Each of the next $n$ lines contains two integers $x_i$, $y_i$ ($0 \le x_i, y_i \le 10^9$) — $x$-coordinate of the key point $p_i$ and $y$-coordinate of the key point $p_i$. It is guaranteed that all the points are distinct and the point $(0, 0)$ is not in this set.
-----Output-----
Print one integer — the minimum possible total distance Maksim has to travel if he needs to visit all key points in a way described above.
-----Examples-----
Input
8
2 2
1 4
2 3
3 1
3 4
1 1
4 3
1 2
Output
15
Input
5
2 1
1 0
2 0
3 2
0 3
Output
9
-----Note-----
The picture corresponding to the first example: [Image]
There is one of the possible answers of length $15$.
The picture corresponding to the second example: [Image]
There is one of the possible answers of length $9$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def solve():
Point=[]
n=int(input())
for i in range(n):
x,y=list(map(int,input().split()))
Point.append((x,y))
data={}
for each in Point:
if each[0]<each[1]:
try:
tm=data[each[1]]
except KeyError:
data[each[1]]={}
try:
data[each[1]]['xi']=min(data[each[1]]['xi'],each[0])
except KeyError:
data[each[1]]['xi']=each[0]
try:
data[each[1]]['xa'] = max(data[each[1]]['xa'], each[0])
except KeyError:
data[each[1]]['xa'] = each[0]
else:
try:
tm=data[each[0]]
except KeyError:
data[each[0]]={}
try:
data[each[0]]['yi']=min(data[each[0]]['yi'],each[1])
except KeyError:
data[each[0]]['yi']=each[1]
try:
data[each[0]]['ya']=max(data[each[0]]['ya'],each[1])
except KeyError:
data[each[0]]['ya'] = each[1]
pre1=(0,0,0)
pre2=(0,0,0)
for each in sorted(data.keys()):
x1,y1,w1=pre1
x2,y2,w2=pre2
if len(data[each])==2:
if 'xa' in data[each]:
x3, y3 = data[each]['xa'], each
x4, y4 = data[each]['xi'], each
if 'ya' in data[each]:
x3, y3 = each, data[each]['ya']
x4, y4 = each, data[each]['yi']
else:
x3,y3=data[each]['xi'],each
x4,y4=each,data[each]['yi']
d=abs(x3-x4)+abs(y3-y4)
pre1 = (x3, y3, min(abs(x1 - x4) + abs(y1 - y4) + w1 + d, abs(x2 - x4) + abs(y2 - y4) + w2 + d))
pre2=(x4,y4,min(abs(x1-x3)+abs(y1-y3)+w1+d,abs(x2-x3)+abs(y2-y3)+w2+d))
print(min(pre1[2],pre2[2]))
def __starting_point():
solve()
__starting_point()
``` | vfc_26459 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1066/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "8\n2 2\n1 4\n2 3\n3 1\n3 4\n1 1\n4 3\n1 2\n",
"output": "15\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n2 1\n1 0\n2 0\n3 2\n0 3\n",
"output": "9\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4445 | Solve the following coding problem using the programming language python:
Polycarp has an array $a$ consisting of $n$ integers.
He wants to play a game with this array. The game consists of several moves. On the first move he chooses any element and deletes it (after the first move the array contains $n-1$ elements). For each of the next moves he chooses any element with the only restriction: its parity should differ from the parity of the element deleted on the previous move. In other words, he alternates parities (even-odd-even-odd-... or odd-even-odd-even-...) of the removed elements. Polycarp stops if he can't make a move.
Formally: If it is the first move, he chooses any element and deletes it; If it is the second or any next move: if the last deleted element was odd, Polycarp chooses any even element and deletes it; if the last deleted element was even, Polycarp chooses any odd element and deletes it. If after some move Polycarp cannot make a move, the game ends.
Polycarp's goal is to minimize the sum of non-deleted elements of the array after end of the game. If Polycarp can delete the whole array, then the sum of non-deleted elements is zero.
Help Polycarp find this value.
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 2000$) — the number of elements of $a$.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($0 \le a_i \le 10^6$), where $a_i$ is the $i$-th element of $a$.
-----Output-----
Print one integer — the minimum possible sum of non-deleted elements of the array after end of the game.
-----Examples-----
Input
5
1 5 7 8 2
Output
0
Input
6
5 1 2 4 6 3
Output
0
Input
2
1000000 1000000
Output
1000000
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n = int(input())
a = list(map(int, input().split()))
odd = []
even = []
for i in a:
if i%2:
odd.append(i)
else:
even.append(i)
odd.sort()
even.sort()
if abs(len(odd) - len(even)) <= 1:
print(0)
else:
if len(odd) > len(even):
print(sum(odd[:len(odd)-len(even)-1]))
else:
print(sum(even[:len(even) - len(odd)-1]))
``` | vfc_26487 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1144/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n1 5 7 8 2\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\n5 1 2 4 6 3\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1000000 1000000\n",
"output": "1000000\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n2 1 1 1 1\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n1 1 1 1 1\n",
"output": "4\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4446 | Solve the following coding problem using the programming language python:
There are $n$ monsters standing in a row numbered from $1$ to $n$. The $i$-th monster has $h_i$ health points (hp). You have your attack power equal to $a$ hp and your opponent has his attack power equal to $b$ hp.
You and your opponent are fighting these monsters. Firstly, you and your opponent go to the first monster and fight it till his death, then you and your opponent go the second monster and fight it till his death, and so on. A monster is considered dead if its hp is less than or equal to $0$.
The fight with a monster happens in turns. You hit the monster by $a$ hp. If it is dead after your hit, you gain one point and you both proceed to the next monster. Your opponent hits the monster by $b$ hp. If it is dead after his hit, nobody gains a point and you both proceed to the next monster.
You have some secret technique to force your opponent to skip his turn. You can use this technique at most $k$ times in total (for example, if there are two monsters and $k=4$, then you can use the technique $2$ times on the first monster and $1$ time on the second monster, but not $2$ times on the first monster and $3$ times on the second monster).
Your task is to determine the maximum number of points you can gain if you use the secret technique optimally.
-----Input-----
The first line of the input contains four integers $n, a, b$ and $k$ ($1 \le n \le 2 \cdot 10^5, 1 \le a, b, k \le 10^9$) — the number of monsters, your attack power, the opponent's attack power and the number of times you can use the secret technique.
The second line of the input contains $n$ integers $h_1, h_2, \dots, h_n$ ($1 \le h_i \le 10^9$), where $h_i$ is the health points of the $i$-th monster.
-----Output-----
Print one integer — the maximum number of points you can gain if you use the secret technique optimally.
-----Examples-----
Input
6 2 3 3
7 10 50 12 1 8
Output
5
Input
1 1 100 99
100
Output
1
Input
7 4 2 1
1 3 5 4 2 7 6
Output
6
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n, a, b, k = map(int, input().split())
H = list(map(int, input().split()))
for i in range(n):
H[i] %= (a + b)
if H[i] == 0:
H[i] = a + b
H.sort()
ans = 0
for x in H:
if x <= a:
ans += 1
else:
tok = (x + a - 1) // a - 1
if k >= tok:
k -= tok
ans += 1
print(ans)
``` | vfc_26491 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1296/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6 2 3 3\n7 10 50 12 1 8\n",
"output": "5\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4447 | Solve the following coding problem using the programming language python:
You are given an array consisting of $n$ integers $a_1, a_2, \dots, a_n$, and a positive integer $m$. It is guaranteed that $m$ is a divisor of $n$.
In a single move, you can choose any position $i$ between $1$ and $n$ and increase $a_i$ by $1$.
Let's calculate $c_r$ ($0 \le r \le m-1)$ — the number of elements having remainder $r$ when divided by $m$. In other words, for each remainder, let's find the number of corresponding elements in $a$ with that remainder.
Your task is to change the array in such a way that $c_0 = c_1 = \dots = c_{m-1} = \frac{n}{m}$.
Find the minimum number of moves to satisfy the above requirement.
-----Input-----
The first line of input contains two integers $n$ and $m$ ($1 \le n \le 2 \cdot 10^5, 1 \le m \le n$). It is guaranteed that $m$ is a divisor of $n$.
The second line of input contains $n$ integers $a_1, a_2, \dots, a_n$ ($0 \le a_i \le 10^9$), the elements of the array.
-----Output-----
In the first line, print a single integer — the minimum number of moves required to satisfy the following condition: for each remainder from $0$ to $m - 1$, the number of elements of the array having this remainder equals $\frac{n}{m}$.
In the second line, print any array satisfying the condition and can be obtained from the given array with the minimum number of moves. The values of the elements of the resulting array must not exceed $10^{18}$.
-----Examples-----
Input
6 3
3 2 0 6 10 12
Output
3
3 2 0 7 10 14
Input
4 2
0 1 2 3
Output
0
0 1 2 3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import bisect
n, m = map(int, input().split())
ls = list(map(int, input().split()))
mls = []
for i in range(0, n):
mls.append((ls[i] % m, i))
mls.sort()
# print(mls)
bk1 = set()
bk2 = set()
aim = n // m
cnt = 0
mis = []
for i in range(m):
for j in range(aim):
mis.append(i)
p1 = 0
p2 = 0
while p2 < n:
if mls[p1][0] > mis[p2]:
p2 += 1
else:
a = mis[p2] - mls[p1][0]
ls[mls[p1][1]] += a
cnt += a
bk2.add(p2)
p1 += 1
p2 += 1
if p1 < n and p2 == n:
p1 = n
for i in range(p2):
if i not in bk2:
p1 -= 1
a = m - mls[p1][0] + mis[i]
ls[mls[p1][1]] += a
cnt += a
print(cnt)
for i in ls:
print(i, end=' ')
``` | vfc_26495 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/999/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6 3\n3 2 0 6 10 12\n",
"output": "3\n3 2 0 7 10 14 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4448 | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions is constraints.
Ivan plays a computer game that contains some microtransactions to make characters look cooler. Since Ivan wants his character to be really cool, he wants to use some of these microtransactions — and he won't start playing until he gets all of them.
Each day (during the morning) Ivan earns exactly one burle.
There are $n$ types of microtransactions in the game. Each microtransaction costs $2$ burles usually and $1$ burle if it is on sale. Ivan has to order exactly $k_i$ microtransactions of the $i$-th type (he orders microtransactions during the evening).
Ivan can order any (possibly zero) number of microtransactions of any types during any day (of course, if he has enough money to do it). If the microtransaction he wants to order is on sale then he can buy it for $1$ burle and otherwise he can buy it for $2$ burles.
There are also $m$ special offers in the game shop. The $j$-th offer $(d_j, t_j)$ means that microtransactions of the $t_j$-th type are on sale during the $d_j$-th day.
Ivan wants to order all microtransactions as soon as possible. Your task is to calculate the minimum day when he can buy all microtransactions he want and actually start playing.
-----Input-----
The first line of the input contains two integers $n$ and $m$ ($1 \le n, m \le 1000$) — the number of types of microtransactions and the number of special offers in the game shop.
The second line of the input contains $n$ integers $k_1, k_2, \dots, k_n$ ($0 \le k_i \le 1000$), where $k_i$ is the number of copies of microtransaction of the $i$-th type Ivan has to order. It is guaranteed that sum of all $k_i$ is not less than $1$ and not greater than $1000$.
The next $m$ lines contain special offers. The $j$-th of these lines contains the $j$-th special offer. It is given as a pair of integers $(d_j, t_j)$ ($1 \le d_j \le 1000, 1 \le t_j \le n$) and means that microtransactions of the $t_j$-th type are on sale during the $d_j$-th day.
-----Output-----
Print one integer — the minimum day when Ivan can order all microtransactions he wants and actually start playing.
-----Examples-----
Input
5 6
1 2 0 2 0
2 4
3 3
1 5
1 2
1 5
2 3
Output
8
Input
5 3
4 2 1 3 2
3 5
4 2
2 5
Output
20
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import collections
def main():
from sys import stdin, stdout
def read():
return stdin.readline().rstrip('\n')
def read_array(sep=None, maxsplit=-1):
return read().split(sep, maxsplit)
def read_int():
return int(read())
def read_int_array(sep=None, maxsplit=-1):
return [int(a) for a in read_array(sep, maxsplit)]
def write(*args, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join(str(a) for a in args) + end)
def write_array(array, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join(str(a) for a in array) + end)
def enough(days):
bought = [] # (type, amount)
bought_total = 0
used_from = days
for d in range(days, 0, -1):
used_from = min(d, used_from)
for t in offers.get(d, []):
if K[t] > 0:
x = min(K[t], used_from)
K[t] -= x
bought.append((t, x))
bought_total += x
used_from -= x
if not used_from:
break
remaining_money = days - bought_total
ans = (total_transaction - bought_total) * 2 <= remaining_money
for t, a in bought:
K[t] += a
return ans
n, m = read_int_array()
K = read_int_array()
total_transaction = sum(K)
offers = collections.defaultdict(list)
for _ in range(m):
d, t = read_int_array()
offers[d].append(t-1)
low = total_transaction
high = low * 2
ans = high
while low <= high:
mid = (low + high) // 2
if enough(mid):
ans = mid
high = mid - 1
else:
low = mid + 1
write(ans)
main()
``` | vfc_26499 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1165/F1",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5 6\n1 2 0 2 0\n2 4\n3 3\n1 5\n1 2\n1 5\n2 3\n",
"output": "8\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 3\n4 2 1 3 2\n3 5\n4 2\n2 5\n",
"output": "20\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "78 36\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0\n1 52\n2 6\n9 43\n10 52\n4 63\n9 35\n10 67\n9 17\n3 43\n4 38\n1 27\n9 44\n6 74\n7 3\n8 18\n1 52\n1 68\n5 51\n5 2\n7 50\n1 72\n1 37\n8 64\n10 30\n2 68\n1 59\n5 12\n9 11\n10 23\n2 51\n10 56\n6 17\n1 49\n3 20\n10 62\n10 40\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10 47\n1 0 0 1 2 1 1 3 1 3\n4 9\n15 5\n6 2\n4 1\n23 3\n9 10\n12 2\n5 10\n2 4\n2 4\n18 4\n23 5\n17 1\n22 3\n24 4\n20 5\n7 3\n17 10\n3 10\n12 10\n4 6\n3 10\n24 2\n12 1\n25 9\n12 5\n25 2\n13 5\n6 5\n4 9\n6 10\n7 2\n7 9\n11 7\n9 4\n1 1\n7 2\n8 1\n11 9\n25 9\n7 8\n9 9\n8 1\n6 4\n22 8\n16 6\n22 6\n",
"output": "13\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 7\n23 78 12 46\n100 1\n41 3\n213 2\n321 3\n12 2\n87 1\n76 2\n",
"output": "213\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4450 | Solve the following coding problem using the programming language python:
You are given a connected undirected weighted graph consisting of $n$ vertices and $m$ edges.
You need to print the $k$-th smallest shortest path in this graph (paths from the vertex to itself are not counted, paths from $i$ to $j$ and from $j$ to $i$ are counted as one).
More formally, if $d$ is the matrix of shortest paths, where $d_{i, j}$ is the length of the shortest path between vertices $i$ and $j$ ($1 \le i < j \le n$), then you need to print the $k$-th element in the sorted array consisting of all $d_{i, j}$, where $1 \le i < j \le n$.
-----Input-----
The first line of the input contains three integers $n, m$ and $k$ ($2 \le n \le 2 \cdot 10^5$, $n - 1 \le m \le \min\Big(\frac{n(n-1)}{2}, 2 \cdot 10^5\Big)$, $1 \le k \le \min\Big(\frac{n(n-1)}{2}, 400\Big)$ — the number of vertices in the graph, the number of edges in the graph and the value of $k$, correspondingly.
Then $m$ lines follow, each containing three integers $x$, $y$ and $w$ ($1 \le x, y \le n$, $1 \le w \le 10^9$, $x \ne y$) denoting an edge between vertices $x$ and $y$ of weight $w$.
It is guaranteed that the given graph is connected (there is a path between any pair of vertices), there are no self-loops (edges connecting the vertex with itself) and multiple edges (for each pair of vertices $x$ and $y$, there is at most one edge between this pair of vertices in the graph).
-----Output-----
Print one integer — the length of the $k$-th smallest shortest path in the given graph (paths from the vertex to itself are not counted, paths from $i$ to $j$ and from $j$ to $i$ are counted as one).
-----Examples-----
Input
6 10 5
2 5 1
5 3 9
6 2 2
1 3 1
5 1 8
6 5 10
1 6 5
6 4 6
3 6 2
3 4 5
Output
3
Input
7 15 18
2 6 3
5 7 4
6 5 4
3 6 9
6 7 7
1 6 4
7 1 6
7 2 1
4 3 2
3 2 8
5 3 6
2 5 5
3 7 9
4 1 8
2 1 1
Output
9
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
input = sys.stdin.readline
n,m,k=list(map(int,input().split()))
EDGE=[list(map(int,input().split())) for i in range(m)]
EDGE.sort(key=lambda x:x[2])
EDGE=EDGE[:k]
COST_vertex=[[] for i in range(n+1)]
for a,b,c in EDGE:
COST_vertex[a].append((b,c))
COST_vertex[b].append((a,c))
for i in range(min(m,k)):
x,y,c=EDGE[i]
EDGE[i]=(c,x,y)
USED_SET=set()
ANS=[-1<<50]*k
import heapq
while EDGE:
c,x,y = heapq.heappop(EDGE)
if (x,y) in USED_SET or c>=-ANS[0]:
continue
else:
heapq.heappop(ANS)
heapq.heappush(ANS,-c)
USED_SET.add((x,y))
USED_SET.add((y,x))
for to,cost in COST_vertex[x]:
if to!=y and not((y,to) in USED_SET) and c+cost<-ANS[0]:
heapq.heappush(EDGE,(c+cost,y,to))
#USED_SET.add((y,to))
#USED_SET.add((to,y))
for to,cost in COST_vertex[y]:
if to!=x and not((x,to) in USED_SET) and c+cost<-ANS[0]:
heapq.heappush(EDGE,(c+cost,x,to))
#USED_SET.add((x,to))
#USED_SET.add((to,x))
print(-ANS[0])
``` | vfc_26507 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1196/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6 10 5\n2 5 1\n5 3 9\n6 2 2\n1 3 1\n5 1 8\n6 5 10\n1 6 5\n6 4 6\n3 6 2\n3 4 5\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "7 15 18\n2 6 3\n5 7 4\n6 5 4\n3 6 9\n6 7 7\n1 6 4\n7 1 6\n7 2 1\n4 3 2\n3 2 8\n5 3 6\n2 5 5\n3 7 9\n4 1 8\n2 1 1\n",
"output": "9\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4452 | Solve the following coding problem using the programming language python:
A positive (strictly greater than zero) integer is called round if it is of the form d00...0. In other words, a positive integer is round if all its digits except the leftmost (most significant) are equal to zero. In particular, all numbers from $1$ to $9$ (inclusive) are round.
For example, the following numbers are round: $4000$, $1$, $9$, $800$, $90$. The following numbers are not round: $110$, $707$, $222$, $1001$.
You are given a positive integer $n$ ($1 \le n \le 10^4$). Represent the number $n$ as a sum of round numbers using the minimum number of summands (addends). In other words, you need to represent the given number $n$ as a sum of the least number of terms, each of which is a round number.
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 10^4$) — the number of test cases in the input. Then $t$ test cases follow.
Each test case is a line containing an integer $n$ ($1 \le n \le 10^4$).
-----Output-----
Print $t$ answers to the test cases. Each answer must begin with an integer $k$ — the minimum number of summands. Next, $k$ terms must follow, each of which is a round number, and their sum is $n$. The terms can be printed in any order. If there are several answers, print any of them.
-----Example-----
Input
5
5009
7
9876
10000
10
Output
2
5000 9
1
7
4
800 70 6 9000
1
10000
1
10
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n = int(input())
# arr = list(map(int, input().split()))
# n, m = map(int, input().split())
arr = []
x = 1
while n > 0:
if (n % 10):
arr.append((n % 10) * x)
n //= 10
x *= 10
print(len(arr))
print(*arr)
``` | vfc_26515 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1352/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n5009\n7\n9876\n10000\n10\n",
"output": "2\n9 5000 \n1\n7 \n4\n6 70 800 9000 \n1\n10000 \n1\n10 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4453 | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions is constraints.
There are $n$ kids, each of them is reading a unique book. At the end of any day, the $i$-th kid will give his book to the $p_i$-th kid (in case of $i = p_i$ the kid will give his book to himself). It is guaranteed that all values of $p_i$ are distinct integers from $1$ to $n$ (i.e. $p$ is a permutation). The sequence $p$ doesn't change from day to day, it is fixed.
For example, if $n=6$ and $p=[4, 6, 1, 3, 5, 2]$ then at the end of the first day the book of the $1$-st kid will belong to the $4$-th kid, the $2$-nd kid will belong to the $6$-th kid and so on. At the end of the second day the book of the $1$-st kid will belong to the $3$-th kid, the $2$-nd kid will belong to the $2$-th kid and so on.
Your task is to determine the number of the day the book of the $i$-th child is returned back to him for the first time for every $i$ from $1$ to $n$.
Consider the following example: $p = [5, 1, 2, 4, 3]$. The book of the $1$-st kid will be passed to the following kids: after the $1$-st day it will belong to the $5$-th kid, after the $2$-nd day it will belong to the $3$-rd kid, after the $3$-rd day it will belong to the $2$-nd kid, after the $4$-th day it will belong to the $1$-st kid.
So after the fourth day, the book of the first kid will return to its owner. The book of the fourth kid will return to him for the first time after exactly one day.
You have to answer $q$ independent queries.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 200$) — the number of queries. Then $q$ queries follow.
The first line of the query contains one integer $n$ ($1 \le n \le 200$) — the number of kids in the query. The second line of the query contains $n$ integers $p_1, p_2, \dots, p_n$ ($1 \le p_i \le n$, all $p_i$ are distinct, i.e. $p$ is a permutation), where $p_i$ is the kid which will get the book of the $i$-th kid.
-----Output-----
For each query, print the answer on it: $n$ integers $a_1, a_2, \dots, a_n$, where $a_i$ is the number of the day the book of the $i$-th child is returned back to him for the first time in this query.
-----Example-----
Input
6
5
1 2 3 4 5
3
2 3 1
6
4 6 2 1 5 3
1
1
4
3 4 1 2
5
5 1 2 4 3
Output
1 1 1 1 1
3 3 3
2 3 3 2 1 3
1
2 2 2 2
4 4 4 1 4
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n = int(input())
P = list(map(int, input().split()))
ans = [0] * n
for i in range(n):
if ans[i] == 0:
now = i
cnt = 0
cll = []
while True:
now = P[now] - 1
cnt += 1
cll.append(now)
if now == i:
break
for u in cll:
ans[u] = cnt
print(' '.join(list(map(str, ans))))
``` | vfc_26519 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1249/B1",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6\n5\n1 2 3 4 5\n3\n2 3 1\n6\n4 6 2 1 5 3\n1\n1\n4\n3 4 1 2\n5\n5 1 2 4 3\n",
"output": "1 1 1 1 1 \n3 3 3 \n2 3 3 2 1 3 \n1 \n2 2 2 2 \n4 4 4 1 4 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n3\n1 2 3\n",
"output": "1 1 1 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "20\n10\n3 8 1 4 9 6 10 2 7 5\n10\n10 4 8 6 5 3 1 2 9 7\n1\n1\n2\n2 1\n10\n2 5 3 6 9 7 4 10 8 1\n10\n1 7 4 6 9 10 8 2 3 5\n8\n3 8 1 7 6 4 2 5\n8\n7 4 5 2 8 1 6 3\n5\n1 2 4 3 5\n6\n4 2 5 6 3 1\n5\n5 3 2 4 1\n5\n4 3 5 1 2\n7\n6 5 1 7 4 2 3\n6\n6 2 4 1 5 3\n3\n3 1 2\n4\n1 3 4 2\n3\n3 1 2\n6\n4 2 1 5 3 6\n9\n4 5 7 8 1 6 2 3 9\n2\n2 1\n",
"output": "2 2 2 1 4 1 4 2 4 4 \n3 5 5 5 1 5 3 5 1 3 \n1 \n2 2 \n6 6 1 3 6 3 3 6 6 6 \n1 3 6 6 6 6 3 3 6 6 \n2 6 2 6 6 6 6 6 \n3 2 3 2 3 3 3 3 \n1 1 2 2 1 \n3 1 2 3 2 3 \n2 2 2 1 2 \n2 3 3 2 3 \n7 7 7 7 7 7 7 \n4 1 4 4 1 4 \n3 3 3 \n1 3 3 3 \n3 3 3 \n4 1 4 4 4 1 \n7 7 7 7 7 1 7 7 1 \n2 2 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "20\n5\n3 4 5 1 2\n6\n3 6 4 5 1 2\n4\n4 2 1 3\n5\n2 5 4 3 1\n6\n5 3 1 6 2 4\n2\n1 2\n4\n4 2 1 3\n9\n1 8 2 4 6 9 5 3 7\n8\n8 5 6 4 3 1 7 2\n4\n3 1 4 2\n2\n1 2\n4\n1 2 3 4\n2\n2 1\n3\n1 3 2\n8\n5 6 3 8 4 1 7 2\n5\n2 4 1 5 3\n5\n5 2 1 4 3\n7\n6 2 5 1 4 7 3\n7\n2 4 6 5 1 7 3\n7\n3 6 2 4 1 7 5\n",
"output": "5 5 5 5 5 \n4 2 4 4 4 2 \n3 1 3 3 \n3 3 2 2 3 \n4 4 4 2 4 2 \n1 1 \n3 1 3 3 \n1 3 3 1 4 4 4 3 4 \n6 6 6 1 6 6 1 6 \n4 4 4 4 \n1 1 \n1 1 1 1 \n2 2 \n1 2 2 \n6 6 1 6 6 6 1 6 \n5 5 5 5 5 \n3 1 3 1 3 \n6 1 6 6 6 6 6 \n4 4 3 4 4 3 3 \n6 6 6 1 6 6 6 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "20\n6\n4 5 6 3 2 1\n7\n1 4 3 6 5 2 7\n10\n4 6 8 2 5 7 3 1 9 10\n6\n4 5 2 3 1 6\n2\n1 2\n7\n4 2 3 7 1 6 5\n10\n3 6 2 8 4 1 7 9 10 5\n3\n1 3 2\n4\n4 3 1 2\n2\n2 1\n1\n1\n1\n1\n5\n1 5 2 3 4\n9\n5 2 8 7 1 6 3 9 4\n6\n2 5 4 6 3 1\n3\n1 2 3\n7\n7 5 2 1 3 4 6\n1\n1\n3\n2 3 1\n7\n3 4 5 2 6 7 1\n",
"output": "4 2 4 4 2 4 \n1 3 1 3 1 3 1 \n7 7 7 7 1 7 7 7 1 1 \n5 5 5 5 5 1 \n1 1 \n4 1 1 4 4 1 4 \n4 4 4 5 5 4 1 5 5 5 \n1 2 2 \n4 4 4 4 \n2 2 \n1 \n1 \n1 4 4 4 4 \n2 1 5 5 2 1 5 5 5 \n6 6 6 6 6 6 \n1 1 1 \n4 3 3 4 3 4 4 \n1 \n3 3 3 \n5 2 5 2 5 5 5 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4454 | Solve the following coding problem using the programming language python:
You are both a shop keeper and a shop assistant at a small nearby shop. You have $n$ goods, the $i$-th good costs $a_i$ coins.
You got tired of remembering the price of each product when customers ask for it, thus you decided to simplify your life. More precisely you decided to set the same price for all $n$ goods you have.
However, you don't want to lose any money so you want to choose the price in such a way that the sum of new prices is not less than the sum of the initial prices. It means that if you sell all $n$ goods for the new price, you will receive at least the same (or greater) amount of money as if you sell them for their initial prices.
On the other hand, you don't want to lose customers because of big prices so among all prices you can choose you need to choose the minimum one.
So you need to find the minimum possible equal price of all $n$ goods so if you sell them for this price, you will receive at least the same (or greater) amount of money as if you sell them for their initial prices.
You have to answer $q$ independent queries.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 100$) — the number of queries. Then $q$ queries follow.
The first line of the query contains one integer $n$ ($1 \le n \le 100)$ — the number of goods. The second line of the query contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^7$), where $a_i$ is the price of the $i$-th good.
-----Output-----
For each query, print the answer for it — the minimum possible equal price of all $n$ goods so if you sell them for this price, you will receive at least the same (or greater) amount of money as if you sell them for their initial prices.
-----Example-----
Input
3
5
1 2 3 4 5
3
1 2 2
4
1 1 1 1
Output
3
2
1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n = int(input())
A = list(map(int, input().split()))
s = sum(A)
print((s + n - 1) // n)
``` | vfc_26523 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1234/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n5\n1 2 3 4 5\n3\n1 2 2\n4\n1 1 1 1\n",
"output": "3\n2\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n2\n777 1\n",
"output": "389\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1\n2441139\n",
"output": "2441139\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n5\n1 2 3 4 5\n3\n1 2 3\n2\n777 778\n",
"output": "3\n2\n778\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n2\n777 778\n",
"output": "778\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4455 | Solve the following coding problem using the programming language python:
In BerSoft $n$ programmers work, the programmer $i$ is characterized by a skill $r_i$.
A programmer $a$ can be a mentor of a programmer $b$ if and only if the skill of the programmer $a$ is strictly greater than the skill of the programmer $b$ $(r_a > r_b)$ and programmers $a$ and $b$ are not in a quarrel.
You are given the skills of each programmers and a list of $k$ pairs of the programmers, which are in a quarrel (pairs are unordered). For each programmer $i$, find the number of programmers, for which the programmer $i$ can be a mentor.
-----Input-----
The first line contains two integers $n$ and $k$ $(2 \le n \le 2 \cdot 10^5$, $0 \le k \le \min(2 \cdot 10^5, \frac{n \cdot (n - 1)}{2}))$ — total number of programmers and number of pairs of programmers which are in a quarrel.
The second line contains a sequence of integers $r_1, r_2, \dots, r_n$ $(1 \le r_i \le 10^{9})$, where $r_i$ equals to the skill of the $i$-th programmer.
Each of the following $k$ lines contains two distinct integers $x$, $y$ $(1 \le x, y \le n$, $x \ne y)$ — pair of programmers in a quarrel. The pairs are unordered, it means that if $x$ is in a quarrel with $y$ then $y$ is in a quarrel with $x$. Guaranteed, that for each pair $(x, y)$ there are no other pairs $(x, y)$ and $(y, x)$ in the input.
-----Output-----
Print $n$ integers, the $i$-th number should be equal to the number of programmers, for which the $i$-th programmer can be a mentor. Programmers are numbered in the same order that their skills are given in the input.
-----Examples-----
Input
4 2
10 4 10 15
1 2
4 3
Output
0 0 1 2
Input
10 4
5 4 1 5 4 3 7 1 2 5
4 6
2 1
10 8
3 5
Output
5 4 0 5 3 3 9 0 2 5
-----Note-----
In the first example, the first programmer can not be mentor of any other (because only the second programmer has a skill, lower than first programmer skill, but they are in a quarrel). The second programmer can not be mentor of any other programmer, because his skill is minimal among others. The third programmer can be a mentor of the second programmer. The fourth programmer can be a mentor of the first and of the second programmers. He can not be a mentor of the third programmer, because they are in a quarrel.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def ke(i):
return a[i]
n,m=map(int,input().split())
a=list(map(int,input().split()))
b=[]
for i in range(n):
b.append(i)
b.sort(key=ke)
ans=[0]*n
k=0
for i in range(1,n):
if a[b[i]]==a[b[i-1]]:
k+=1
ans[b[i]]=i-k
else:
k=0
ans[b[i]]=i
for i in range(m):
r1,r2=map(int,input().split())
if (a[r1-1]>a[r2-1]):
ans[r1-1]-=1
elif a[r1-1]<a[r2-1]:
ans[r2-1]-=1
for i in ans:
print(i, end=' ')
``` | vfc_26527 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/978/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 2\n10 4 10 15\n1 2\n4 3\n",
"output": "0 0 1 2 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4456 | Solve the following coding problem using the programming language python:
Authors have come up with the string $s$ consisting of $n$ lowercase Latin letters.
You are given two permutations of its indices (not necessary equal) $p$ and $q$ (both of length $n$). Recall that the permutation is the array of length $n$ which contains each integer from $1$ to $n$ exactly once.
For all $i$ from $1$ to $n-1$ the following properties hold: $s[p_i] \le s[p_{i + 1}]$ and $s[q_i] \le s[q_{i + 1}]$. It means that if you will write down all characters of $s$ in order of permutation indices, the resulting string will be sorted in the non-decreasing order.
Your task is to restore any such string $s$ of length $n$ consisting of at least $k$ distinct lowercase Latin letters which suits the given permutations.
If there are multiple answers, you can print any of them.
-----Input-----
The first line of the input contains two integers $n$ and $k$ ($1 \le n \le 2 \cdot 10^5, 1 \le k \le 26$) — the length of the string and the number of distinct characters required.
The second line of the input contains $n$ integers $p_1, p_2, \dots, p_n$ ($1 \le p_i \le n$, all $p_i$ are distinct integers from $1$ to $n$) — the permutation $p$.
The third line of the input contains $n$ integers $q_1, q_2, \dots, q_n$ ($1 \le q_i \le n$, all $q_i$ are distinct integers from $1$ to $n$) — the permutation $q$.
-----Output-----
If it is impossible to find the suitable string, print "NO" on the first line.
Otherwise print "YES" on the first line and string $s$ on the second line. It should consist of $n$ lowercase Latin letters, contain at least $k$ distinct characters and suit the given permutations.
If there are multiple answers, you can print any of them.
-----Example-----
Input
3 2
1 2 3
1 3 2
Output
YES
abb
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n,k=map(int,input().split())
aa=list(map(int,input().split()))
bb=list(map(int,input().split()))
ab="abcdefghijklmnopqrstuvwxyz"
#print(len(ab))
ss={}
j=0
it=[]
for i in aa:
ss[i]=j
j+=1
jj=0
for i in bb:
ind=ss[i]
j,ind=sorted([jj,ind])
it.append([j,ind])
# print(i,jj,ind)
jj+=1
it.sort()
do=1
ma=it[0][1]
res=[]
st=it[0][0]
for i in it[1:]:
if i[0]<=ma:
ma=max(ma,i[1])
else:
do+=1
res.append([st,ma])
st=i[0]
ma=i[1]
j+=1
if res==[]:
res=[[0,n-1]]
else:
if res[-1][1]!=n-1:
res.append([res[-1][1]+1,n-1])
if len(res)<k:
print("NO")
else:
print("YES")
if len(res)>k:
# print(res[:k-1])
# print(res)
res=res[:k-1]+[[res[k-1][0],n-1]]
kk=-1
res.sort()
ll=[0]*n
for i in res:
kk+=1
for j in range(i[0],i[1]+1):
ll[aa[j]-1]=ab[kk]
for i in ll:
print(i,end="")
print()
``` | vfc_26531 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1213/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 2\n1 2 3\n1 3 2\n",
"output": "YES\nabb\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 4\n1 3 2 4 5\n2 3 5 1 4\n",
"output": "NO\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4457 | Solve the following coding problem using the programming language python:
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed $n$ cans in a row on a table. Cans are numbered from left to right from $1$ to $n$. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the $i$-th can is $a_i$. It means that if Vasya has already knocked $x$ cans down and is now about to start shooting the $i$-th one, he will need $(a_i \cdot x + 1)$ shots to knock it down. You can assume that if Vasya starts shooting the $i$-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the $n$ given cans down exactly once is minimum possible.
-----Input-----
The first line of the input contains one integer $n$ $(2 \le n \le 1\,000)$ — the number of cans.
The second line of the input contains the sequence $a_1, a_2, \dots, a_n$ $(1 \le a_i \le 1\,000)$, where $a_i$ is the durability of the $i$-th can.
-----Output-----
In the first line print the minimum number of shots required to knock each of the $n$ given cans down exactly once.
In the second line print the sequence consisting of $n$ distinct integers from $1$ to $n$ — the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
-----Examples-----
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
-----Note-----
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots $20 \cdot 1 + 1 = 21$ times. After that only second can remains. To knock it down Vasya shoots $10 \cdot 2 + 1 = 21$ times. So the total number of shots is $1 + 21 + 21 = 43$.
In the second example the order of shooting does not matter because all cans have the same durability.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n = int(input())
a = [int(x) for x in input().split()]
b = [(a[i], i + 1) for i in range(n)]
b.sort(reverse=True)
ans = 0
for i in range(n):
ans += b[i][0] * i + 1
print(ans)
for i in b:
print(i[1], end=' ')
``` | vfc_26535 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1216/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n20 10 20\n",
"output": "43\n1 3 2 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n10 10 10 10\n",
"output": "64\n2 1 4 3 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\n5 4 5 4 4 5\n",
"output": "69\n6 1 3 5 2 4 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1 4\n",
"output": "3\n2 1 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n13 16 20 18 11\n",
"output": "138\n3 4 2 1 5 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4469 | Solve the following coding problem using the programming language python:
You have got a shelf and want to put some books on it.
You are given $q$ queries of three types: L $id$ — put a book having index $id$ on the shelf to the left from the leftmost existing book; R $id$ — put a book having index $id$ on the shelf to the right from the rightmost existing book; ? $id$ — calculate the minimum number of books you need to pop from the left or from the right in such a way that the book with index $id$ will be leftmost or rightmost.
You can assume that the first book you will put can have any position (it does not matter) and queries of type $3$ are always valid (it is guaranteed that the book in each such query is already placed). You can also assume that you don't put the same book on the shelf twice, so $id$s don't repeat in queries of first two types.
Your problem is to answer all the queries of type $3$ in order they appear in the input.
Note that after answering the query of type $3$ all the books remain on the shelf and the relative order of books does not change.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 2 \cdot 10^5$) — the number of queries.
Then $q$ lines follow. The $i$-th line contains the $i$-th query in format as in the problem statement. It is guaranteed that queries are always valid (for query type $3$, it is guaranteed that the book in each such query is already placed, and for other types, it is guaranteed that the book was not placed before).
It is guaranteed that there is at least one query of type $3$ in the input.
In each query the constraint $1 \le id \le 2 \cdot 10^5$ is met.
-----Output-----
Print answers to queries of the type $3$ in order they appear in the input.
-----Examples-----
Input
8
L 1
R 2
R 3
? 2
L 4
? 1
L 5
? 1
Output
1
1
2
Input
10
L 100
R 100000
R 123
L 101
? 123
L 10
R 115
? 100
R 110
? 115
Output
0
2
1
-----Note-----
Let's take a look at the first example and let's consider queries: The shelf will look like $[1]$; The shelf will look like $[1, 2]$; The shelf will look like $[1, 2, 3]$; The shelf looks like $[1, \textbf{2}, 3]$ so the answer is $1$; The shelf will look like $[4, 1, 2, 3]$; The shelf looks like $[4, \textbf{1}, 2, 3]$ so the answer is $1$; The shelf will look like $[5, 4, 1, 2, 3]$; The shelf looks like $[5, 4, \textbf{1}, 2, 3]$ so the answer is $2$.
Let's take a look at the second example and let's consider queries: The shelf will look like $[100]$; The shelf will look like $[100, 100000]$; The shelf will look like $[100, 100000, 123]$; The shelf will look like $[101, 100, 100000, 123]$; The shelf looks like $[101, 100, 100000, \textbf{123}]$ so the answer is $0$; The shelf will look like $[10, 101, 100, 100000, 123]$; The shelf will look like $[10, 101, 100, 100000, 123, 115]$; The shelf looks like $[10, 101, \textbf{100}, 100000, 123, 115]$ so the answer is $2$; The shelf will look like $[10, 101, 100, 100000, 123, 115, 110]$; The shelf looks like $[10, 101, 100, 100000, 123, \textbf{115}, 110]$ so the answer is $1$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n = int(input())
d = {}
matr = [0] * (2 * n + 1)
head = n - 1
tail = n
for i in range(n):
st, n = input().split()
n = int(n)
if st == 'L':
matr[head] = n
d[n] = head
head -= 1
elif st == 'R':
matr[tail] = n
d[n] = tail
tail += 1
else:
print(min(d[n] - head, tail - d[n]) - 1)
``` | vfc_26583 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1066/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "8\nL 1\nR 2\nR 3\n? 2\nL 4\n? 1\nL 5\n? 1\n",
"output": "1\n1\n2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\nL 100\nR 100000\nR 123\nL 101\n? 123\nL 10\nR 115\n? 100\nR 110\n? 115\n",
"output": "0\n2\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\nL 1\nR 2\nR 3\n? 2\nL 4\n? 1\n",
"output": "1\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "7\nL 1\nR 2\nR 3\nL 4\nL 5\n? 1\n? 2\n",
"output": "2\n1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4472 | Solve the following coding problem using the programming language python:
You are given two strings $a$ and $b$ consisting of lowercase English letters, both of length $n$. The characters of both strings have indices from $1$ to $n$, inclusive.
You are allowed to do the following changes: Choose any index $i$ ($1 \le i \le n$) and swap characters $a_i$ and $b_i$; Choose any index $i$ ($1 \le i \le n$) and swap characters $a_i$ and $a_{n - i + 1}$; Choose any index $i$ ($1 \le i \le n$) and swap characters $b_i$ and $b_{n - i + 1}$.
Note that if $n$ is odd, you are formally allowed to swap $a_{\lceil\frac{n}{2}\rceil}$ with $a_{\lceil\frac{n}{2}\rceil}$ (and the same with the string $b$) but this move is useless. Also you can swap two equal characters but this operation is useless as well.
You have to make these strings equal by applying any number of changes described above, in any order. But it is obvious that it may be impossible to make two strings equal by these swaps.
In one preprocess move you can replace a character in $a$ with another character. In other words, in a single preprocess move you can choose any index $i$ ($1 \le i \le n$), any character $c$ and set $a_i := c$.
Your task is to find the minimum number of preprocess moves to apply in such a way that after them you can make strings $a$ and $b$ equal by applying some number of changes described in the list above.
Note that the number of changes you make after the preprocess moves does not matter. Also note that you cannot apply preprocess moves to the string $b$ or make any preprocess moves after the first change is made.
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 10^5$) — the length of strings $a$ and $b$.
The second line contains the string $a$ consisting of exactly $n$ lowercase English letters.
The third line contains the string $b$ consisting of exactly $n$ lowercase English letters.
-----Output-----
Print a single integer — the minimum number of preprocess moves to apply before changes, so that it is possible to make the string $a$ equal to string $b$ with a sequence of changes from the list above.
-----Examples-----
Input
7
abacaba
bacabaa
Output
4
Input
5
zcabd
dbacz
Output
0
-----Note-----
In the first example preprocess moves are as follows: $a_1 := $'b', $a_3 := $'c', $a_4 := $'a' and $a_5:=$'b'. Afterwards, $a = $"bbcabba". Then we can obtain equal strings by the following sequence of changes: $swap(a_2, b_2)$ and $swap(a_2, a_6)$. There is no way to use fewer than $4$ preprocess moves before a sequence of changes to make string equal, so the answer in this example is $4$.
In the second example no preprocess moves are required. We can use the following sequence of changes to make $a$ and $b$ equal: $swap(b_1, b_5)$, $swap(a_2, a_4)$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from math import ceil
n = int(input())
word1 = input()
word2 = input()
combined = []
for i in range(ceil(n / 2)):
if i > n / 2 - 1:
combined.append([word1[i], word2[i]])
else:
combined.append([word1[i], word1[- i - 1], word2[i], word2[- i - 1]])
count = 0
for l in combined:
s = set(l)
if len(s) == 4:
count += 2
elif len(s) == 3:
count += 1
if l[0] == l[1]:
count += 1
elif len(s) == 2:
counter = 0
first_letter = l[0]
for letter in l:
if letter == first_letter:
counter += 1
if counter != 2:
count += 1
print(count)
``` | vfc_26595 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1006/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7\nabacaba\nbacabaa\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\nzcabd\ndbacz\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\na\nb\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4473 | Solve the following coding problem using the programming language python:
A frog is currently at the point $0$ on a coordinate axis $Ox$. It jumps by the following algorithm: the first jump is $a$ units to the right, the second jump is $b$ units to the left, the third jump is $a$ units to the right, the fourth jump is $b$ units to the left, and so on.
Formally: if the frog has jumped an even number of times (before the current jump), it jumps from its current position $x$ to position $x+a$; otherwise it jumps from its current position $x$ to position $x-b$.
Your task is to calculate the position of the frog after $k$ jumps.
But... One more thing. You are watching $t$ different frogs so you have to answer $t$ independent queries.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 1000$) — the number of queries.
Each of the next $t$ lines contain queries (one query per line).
The query is described as three space-separated integers $a, b, k$ ($1 \le a, b, k \le 10^9$) — the lengths of two types of jumps and the number of jumps, respectively.
-----Output-----
Print $t$ integers. The $i$-th integer should be the answer for the $i$-th query.
-----Example-----
Input
6
5 2 3
100 1 4
1 10 5
1000000000 1 6
1 1 1000000000
1 1 999999999
Output
8
198
-17
2999999997
0
1
-----Note-----
In the first query frog jumps $5$ to the right, $2$ to the left and $5$ to the right so the answer is $5 - 2 + 5 = 8$.
In the second query frog jumps $100$ to the right, $1$ to the left, $100$ to the right and $1$ to the left so the answer is $100 - 1 + 100 - 1 = 198$.
In the third query the answer is $1 - 10 + 1 - 10 + 1 = -17$.
In the fourth query the answer is $10^9 - 1 + 10^9 - 1 + 10^9 - 1 = 2999999997$.
In the fifth query all frog's jumps are neutralized by each other so the answer is $0$.
The sixth query is the same as the fifth but without the last jump so the answer is $1$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t = int(input())
for i in range(t):
a, b, k = list(map(int, input().split()))
ans = (a - b) * (k // 2)
if k % 2 == 1:
ans += a
print(ans)
``` | vfc_26599 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1077/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6\n5 2 3\n100 1 4\n1 10 5\n1000000000 1 6\n1 1 1000000000\n1 1 999999999\n",
"output": "8\n198\n-17\n2999999997\n0\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n19280817 1 1\n",
"output": "19280817\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n598 56 799\n",
"output": "216856\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n599 56 799\n",
"output": "217256\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4474 | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions is the maximum value of $n$.
You are given a positive integer number $n$. You really love good numbers so you want to find the smallest good number greater than or equal to $n$.
The positive integer is called good if it can be represented as a sum of distinct powers of $3$ (i.e. no duplicates of powers of $3$ are allowed).
For example:
$30$ is a good number: $30 = 3^3 + 3^1$, $1$ is a good number: $1 = 3^0$, $12$ is a good number: $12 = 3^2 + 3^1$, but $2$ is not a good number: you can't represent it as a sum of distinct powers of $3$ ($2 = 3^0 + 3^0$), $19$ is not a good number: you can't represent it as a sum of distinct powers of $3$ (for example, the representations $19 = 3^2 + 3^2 + 3^0 = 3^2 + 3^1 + 3^1 + 3^1 + 3^0$ are invalid), $20$ is also not a good number: you can't represent it as a sum of distinct powers of $3$ (for example, the representation $20 = 3^2 + 3^2 + 3^0 + 3^0$ is invalid).
Note, that there exist other representations of $19$ and $20$ as sums of powers of $3$ but none of them consists of distinct powers of $3$.
For the given positive integer $n$ find such smallest $m$ ($n \le m$) that $m$ is a good number.
You have to answer $q$ independent queries.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 500$) — the number of queries. Then $q$ queries follow.
The only line of the query contains one integer $n$ ($1 \le n \le 10^{18}$).
-----Output-----
For each query, print such smallest integer $m$ (where $n \le m$) that $m$ is a good number.
-----Example-----
Input
8
1
2
6
13
14
3620
10000
1000000000000000000
Output
1
3
9
13
27
6561
19683
1350851717672992089
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n = int(input())
bits = ['1']
while int(''.join(bits), 3) < n:
bits.append('1')
for i in range(len(bits)):
bits[i] = '0'
if int(''.join(bits), 3) < n:
bits[i] = '1'
print(int(''.join(bits), 3))
``` | vfc_26603 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1249/C2",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "8\n1\n2\n6\n13\n14\n3620\n10000\n1000000000000000000\n",
"output": "1\n3\n9\n13\n27\n6561\n19683\n1350851717672992089\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n450283905890997363\n",
"output": "450283905890997363\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4475 | Solve the following coding problem using the programming language python:
You are given four integers $a$, $b$, $x$ and $y$. Initially, $a \ge x$ and $b \ge y$. You can do the following operation no more than $n$ times:
Choose either $a$ or $b$ and decrease it by one. However, as a result of this operation, value of $a$ cannot become less than $x$, and value of $b$ cannot become less than $y$.
Your task is to find the minimum possible product of $a$ and $b$ ($a \cdot b$) you can achieve by applying the given operation no more than $n$ times.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 2 \cdot 10^4$) — the number of test cases. Then $t$ test cases follow.
The only line of the test case contains five integers $a$, $b$, $x$, $y$ and $n$ ($1 \le a, b, x, y, n \le 10^9$). Additional constraint on the input: $a \ge x$ and $b \ge y$ always holds.
-----Output-----
For each test case, print one integer: the minimum possible product of $a$ and $b$ ($a \cdot b$) you can achieve by applying the given operation no more than $n$ times.
-----Example-----
Input
7
10 10 8 5 3
12 8 8 7 2
12343 43 4543 39 123212
1000000000 1000000000 1 1 1
1000000000 1000000000 1 1 1000000000
10 11 2 1 5
10 11 9 1 10
Output
70
77
177177
999999999000000000
999999999
55
10
-----Note-----
In the first test case of the example, you need to decrease $b$ three times and obtain $10 \cdot 7 = 70$.
In the second test case of the example, you need to decrease $a$ one time, $b$ one time and obtain $11 \cdot 7 = 77$.
In the sixth test case of the example, you need to decrease $a$ five times and obtain $5 \cdot 11 = 55$.
In the seventh test case of the example, you need to decrease $b$ ten times and obtain $10 \cdot 1 = 10$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t = int(input())
# a = list(map(int, input().split()))
for _ in range(t):
a,b,x,y,n = map(int,input().split())
options = []
a2 = max(a-n,x)
b2 = max(b-(n-(a-a2)),y)
options.append(a2*b2)
b2 = max(b-n,y)
a2 = max(a-(n-(b-b2)),x)
options.append(a2*b2)
print(min(options))
``` | vfc_26607 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1409/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7\n10 10 8 5 3\n12 8 8 7 2\n12343 43 4543 39 123212\n1000000000 1000000000 1 1 1\n1000000000 1000000000 1 1 1000000000\n10 11 2 1 5\n10 11 9 1 10\n",
"output": "70\n77\n177177\n999999999000000000\n999999999\n55\n10\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n10 10 8 5 3\n",
"output": "70\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4476 | Solve the following coding problem using the programming language python:
You are given two positive integers $a$ and $b$.
In one move, you can change $a$ in the following way:
Choose any positive odd integer $x$ ($x > 0$) and replace $a$ with $a+x$; choose any positive even integer $y$ ($y > 0$) and replace $a$ with $a-y$.
You can perform as many such operations as you want. You can choose the same numbers $x$ and $y$ in different moves.
Your task is to find the minimum number of moves required to obtain $b$ from $a$. It is guaranteed that you can always obtain $b$ from $a$.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 10^4$) — the number of test cases.
Then $t$ test cases follow. Each test case is given as two space-separated integers $a$ and $b$ ($1 \le a, b \le 10^9$).
-----Output-----
For each test case, print the answer — the minimum number of moves required to obtain $b$ from $a$ if you can perform any number of moves described in the problem statement. It is guaranteed that you can always obtain $b$ from $a$.
-----Example-----
Input
5
2 3
10 10
2 4
7 4
9 3
Output
1
0
2
2
1
-----Note-----
In the first test case, you can just add $1$.
In the second test case, you don't need to do anything.
In the third test case, you can add $1$ two times.
In the fourth test case, you can subtract $4$ and add $1$.
In the fifth test case, you can just subtract $6$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
a, b = list(map(int, input().split()))
if a == b:
print(0)
else:
if a < b:
if (b - a) % 2:
print(1)
else:
print(2)
else:
if (b - a) % 2 == 0:
print(1)
else:
print(2)
``` | vfc_26611 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1311/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n2 3\n10 10\n2 4\n7 4\n9 3\n",
"output": "1\n0\n2\n2\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n19260817 114514\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n484887 54\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n55678978 55678978\n",
"output": "0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4506 | Solve the following coding problem using the programming language python:
You are given two arrays $a$ and $b$, both of length $n$.
Let's define a function $f(l, r) = \sum\limits_{l \le i \le r} a_i \cdot b_i$.
Your task is to reorder the elements (choose an arbitrary order of elements) of the array $b$ to minimize the value of $\sum\limits_{1 \le l \le r \le n} f(l, r)$. Since the answer can be very large, you have to print it modulo $998244353$. Note that you should minimize the answer but not its remainder.
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the number of elements in $a$ and $b$.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^6$), where $a_i$ is the $i$-th element of $a$.
The third line of the input contains $n$ integers $b_1, b_2, \dots, b_n$ ($1 \le b_j \le 10^6$), where $b_j$ is the $j$-th element of $b$.
-----Output-----
Print one integer — the minimum possible value of $\sum\limits_{1 \le l \le r \le n} f(l, r)$ after rearranging elements of $b$, taken modulo $998244353$. Note that you should minimize the answer but not its remainder.
-----Examples-----
Input
5
1 8 7 2 4
9 7 2 9 3
Output
646
Input
1
1000000
1000000
Output
757402647
Input
2
1 3
4 2
Output
20
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n = int(input())
a = list(map(int, input().split()))
aord = sorted([i for i in range(n)], key=lambda x: a[x] * (n - x) * (x + 1))
b = sorted(map(int, input().split()))[::-1]
new_b = [0] * n
for i in range(n):
new_b[aord[i]] = b[i]
b = new_b
m = 998244353
c = [0] * n
for i in range(n):
c[i] = a[i] * b[i] % m
ans = 0
for i in range(n):
u = c[i] * (n - i) * (i + 1) % m
ans = (ans + u) % m
print(ans)
``` | vfc_26725 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1165/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n1 8 7 2 4\n9 7 2 9 3\n",
"output": "646\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1000000\n1000000\n",
"output": "757402647\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1 3\n4 2\n",
"output": "20\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4507 | Solve the following coding problem using the programming language python:
There are $n$ shovels in the nearby shop. The $i$-th shovel costs $a_i$ bourles.
Misha has to buy exactly $k$ shovels. Each shovel can be bought no more than once.
Misha can buy shovels by several purchases. During one purchase he can choose any subset of remaining (non-bought) shovels and buy this subset.
There are also $m$ special offers in the shop. The $j$-th of them is given as a pair $(x_j, y_j)$, and it means that if Misha buys exactly $x_j$ shovels during one purchase then $y_j$ most cheapest of them are for free (i.e. he will not pay for $y_j$ most cheapest shovels during the current purchase).
Misha can use any offer any (possibly, zero) number of times, but he cannot use more than one offer during one purchase (but he can buy shovels without using any offers).
Your task is to calculate the minimum cost of buying $k$ shovels, if Misha buys them optimally.
-----Input-----
The first line of the input contains three integers $n, m$ and $k$ ($1 \le n, m \le 2 \cdot 10^5, 1 \le k \le min(n, 2000)$) — the number of shovels in the shop, the number of special offers and the number of shovels Misha has to buy, correspondingly.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 2 \cdot 10^5$), where $a_i$ is the cost of the $i$-th shovel.
The next $m$ lines contain special offers. The $j$-th of them is given as a pair of integers $(x_i, y_i)$ ($1 \le y_i \le x_i \le n$) and means that if Misha buys exactly $x_i$ shovels during some purchase, then he can take $y_i$ most cheapest of them for free.
-----Output-----
Print one integer — the minimum cost of buying $k$ shovels if Misha buys them optimally.
-----Examples-----
Input
7 4 5
2 5 4 2 6 3 1
2 1
6 5
2 1
3 1
Output
7
Input
9 4 8
6 8 5 1 8 1 1 2 1
9 2
8 4
5 3
9 7
Output
17
Input
5 1 4
2 5 7 4 6
5 4
Output
17
-----Note-----
In the first example Misha can buy shovels on positions $1$ and $4$ (both with costs $2$) during the first purchase and get one of them for free using the first or the third special offer. And then he can buy shovels on positions $3$ and $6$ (with costs $4$ and $3$) during the second purchase and get the second one for free using the first or the third special offer. Then he can buy the shovel on a position $7$ with cost $1$. So the total cost is $4 + 2 + 1 = 7$.
In the second example Misha can buy shovels on positions $1$, $2$, $3$, $4$ and $8$ (costs are $6$, $8$, $5$, $1$ and $2$) and get three cheapest (with costs $5$, $1$ and $2$) for free. And then he can buy shovels on positions $6$, $7$ and $9$ (all with costs $1$) without using any special offers. So the total cost is $6 + 8 + 1 + 1 + 1 = 17$.
In the third example Misha can buy four cheapest shovels without using any special offers and get the total cost $17$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
import copy
input = sys.stdin.readline
n,m,k=list(map(int,input().split()))
A=list(map(int,input().split()))
SHOP=[list(map(int,input().split())) for i in range(m)]
A=sorted(A)[:k]
A=A[::-1]
SHOP.sort(key=lambda x:x[0])
from itertools import accumulate
DP=[0]+list(accumulate(A))
SUM=copy.deepcopy(DP)
for i in range(k+1):
for x,y in SHOP:
if x>i:
break
DP[i]=min(DP[i],DP[i-x]+SUM[i]-SUM[i-x]-SUM[i]+SUM[i-y],DP[i-1]+A[i-1])
print(DP[-1])
``` | vfc_26729 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1154/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7 4 5\n2 5 4 2 6 3 1\n2 1\n6 5\n2 1\n3 1\n",
"output": "7\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4509 | Solve the following coding problem using the programming language python:
You are given two positive integers $n$ and $k$. Print the $k$-th positive integer that is not divisible by $n$.
For example, if $n=3$, and $k=7$, then all numbers that are not divisible by $3$ are: $1, 2, 4, 5, 7, 8, 10, 11, 13 \dots$. The $7$-th number among them is $10$.
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 1000$) — the number of test cases in the input. Next, $t$ test cases are given, one per line.
Each test case is two positive integers $n$ ($2 \le n \le 10^9$) and $k$ ($1 \le k \le 10^9$).
-----Output-----
For each test case print the $k$-th positive integer that is not divisible by $n$.
-----Example-----
Input
6
3 7
4 12
2 1000000000
7 97
1000000000 1000000000
2 1
Output
10
15
1999999999
113
1000000001
1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from sys import *
from collections import *
from math import *
input = stdin.readline
tc = int(input())
for tcase in range(tc):
n, k = map(int, input().split())
lo = 1
hi = 10 ** 19
ans = -1
while (lo <= hi):
mid = (lo + hi) // 2
divi = mid - mid // n
if (divi >= k):
ans = mid
hi = mid - 1
else:
lo = mid + 1
print(ans)
``` | vfc_26737 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1352/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6\n3 7\n4 12\n2 1000000000\n7 97\n1000000000 1000000000\n2 1\n",
"output": "10\n15\n1999999999\n113\n1000000001\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "7\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n",
"output": "1\n1\n1\n1\n1\n1\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n841 4832526\n",
"output": "4838279\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4510 | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions are constraints on $n$ and $k$.
You are messaging in one of the popular social networks via your smartphone. Your smartphone can show at most $k$ most recent conversations with your friends. Initially, the screen is empty (i.e. the number of displayed conversations equals $0$).
Each conversation is between you and some of your friends. There is at most one conversation with any of your friends. So each conversation is uniquely defined by your friend.
You (suddenly!) have the ability to see the future. You know that during the day you will receive $n$ messages, the $i$-th message will be received from the friend with ID $id_i$ ($1 \le id_i \le 10^9$).
If you receive a message from $id_i$ in the conversation which is currently displayed on the smartphone then nothing happens: the conversations of the screen do not change and do not change their order, you read the message and continue waiting for new messages.
Otherwise (i.e. if there is no conversation with $id_i$ on the screen):
Firstly, if the number of conversations displayed on the screen is $k$, the last conversation (which has the position $k$) is removed from the screen. Now the number of conversations on the screen is guaranteed to be less than $k$ and the conversation with the friend $id_i$ is not displayed on the screen. The conversation with the friend $id_i$ appears on the first (the topmost) position on the screen and all the other displayed conversations are shifted one position down.
Your task is to find the list of conversations (in the order they are displayed on the screen) after processing all $n$ messages.
-----Input-----
The first line of the input contains two integers $n$ and $k$ ($1 \le n, k \le 2 \cdot 10^5)$ — the number of messages and the number of conversations your smartphone can show.
The second line of the input contains $n$ integers $id_1, id_2, \dots, id_n$ ($1 \le id_i \le 10^9$), where $id_i$ is the ID of the friend which sends you the $i$-th message.
-----Output-----
In the first line of the output print one integer $m$ ($1 \le m \le min(n, k)$) — the number of conversations shown after receiving all $n$ messages.
In the second line print $m$ integers $ids_1, ids_2, \dots, ids_m$, where $ids_i$ should be equal to the ID of the friend corresponding to the conversation displayed on the position $i$ after receiving all $n$ messages.
-----Examples-----
Input
7 2
1 2 3 2 1 3 2
Output
2
2 1
Input
10 4
2 3 3 1 1 2 1 2 3 3
Output
3
1 3 2
-----Note-----
In the first example the list of conversations will change in the following way (in order from the first to last message):
$[]$; $[1]$; $[2, 1]$; $[3, 2]$; $[3, 2]$; $[1, 3]$; $[1, 3]$; $[2, 1]$.
In the second example the list of conversations will change in the following way:
$[]$; $[2]$; $[3, 2]$; $[3, 2]$; $[1, 3, 2]$; and then the list will not change till the end.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from collections import deque
n, k = map(int, input().split())
A = list(map(int, input().split()))
B = deque()
B.append(A[0])
nc = {}
for i in set(A):
nc[i] = 0
nc[A[0]] = 1
for i in range(1, n):
if nc[A[i]] == 0:
if len(B) == k:
nc[B[0]] -= 1
B.popleft()
B.append(A[i])
nc[A[i]] += 1
else:
pass
print(len(B))
print(*list(B)[::-1])
``` | vfc_26741 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1234/B2",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7 2\n1 2 3 2 1 3 2\n",
"output": "2\n2 1 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10 4\n2 3 3 1 1 2 1 2 3 3\n",
"output": "3\n1 3 2 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 4\n1\n",
"output": "1\n1 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4511 | Solve the following coding problem using the programming language python:
You are playing a computer card game called Splay the Sire. Currently you are struggling to defeat the final boss of the game.
The boss battle consists of $n$ turns. During each turn, you will get several cards. Each card has two parameters: its cost $c_i$ and damage $d_i$. You may play some of your cards during each turn in some sequence (you choose the cards and the exact order they are played), as long as the total cost of the cards you play during the turn does not exceed $3$. After playing some (possibly zero) cards, you end your turn, and all cards you didn't play are discarded. Note that you can use each card at most once.
Your character has also found an artifact that boosts the damage of some of your actions: every $10$-th card you play deals double damage.
What is the maximum possible damage you can deal during $n$ turns?
-----Input-----
The first line contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the number of turns.
Then $n$ blocks of input follow, the $i$-th block representing the cards you get during the $i$-th turn.
Each block begins with a line containing one integer $k_i$ ($1 \le k_i \le 2 \cdot 10^5$) — the number of cards you get during $i$-th turn. Then $k_i$ lines follow, each containing two integers $c_j$ and $d_j$ ($1 \le c_j \le 3$, $1 \le d_j \le 10^9$) — the parameters of the corresponding card.
It is guaranteed that $\sum \limits_{i = 1}^{n} k_i \le 2 \cdot 10^5$.
-----Output-----
Print one integer — the maximum damage you may deal.
-----Example-----
Input
5
3
1 6
1 7
1 5
2
1 4
1 3
3
1 10
3 5
2 3
3
1 15
2 4
1 10
1
1 100
Output
263
-----Note-----
In the example test the best course of action is as follows:
During the first turn, play all three cards in any order and deal $18$ damage.
During the second turn, play both cards and deal $7$ damage.
During the third turn, play the first and the third card and deal $13$ damage.
During the fourth turn, play the first and the third card and deal $25$ damage.
During the fifth turn, play the only card, which will deal double damage ($200$).
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
import math
import cProfile
DEBUG = False
def log(s):
if DEBUG and False:
print(s)
def calc_dmg(num, arr):
maximum = 0
if num - len(arr) < 0:
maximum = max(arr)
return sum(arr) + maximum
if DEBUG:
sys.stdin = open('input.txt')
pr = cProfile.Profile()
pr.enable()
n = sys.stdin.readline()
n = int(n)
dmg = [-sys.maxsize for _ in range(10)]
for i in range(n):
log(dmg)
cards = [_[:] for _ in [[-sys.maxsize] * 3] * 4]
k = sys.stdin.readline()
k = int(k)
for _ in range(k):
c, d = sys.stdin.readline().split()
c = int(c)
d = int(d)
cards[c].append(d)
cards[1].sort(reverse=True)
cards[2].sort(reverse=True)
cards[3].sort(reverse=True)
log(cards)
# dmg[j] = max(dmg[j],
# dmg[j - 1] + D(one card),
# dmg[j - 2] + D(two cards),
# dmg[j - 3] + D(three cards))
# Plus, if 1 <= j <= 3, dmg[j] = max(dmg[j], D(cards))
new_dmg = []
for j in range(10):
use1 = max(cards[1][0], cards[2][0], cards[3][0])
use2 = max(cards[1][0] + cards[1][1],
cards[1][0] + cards[2][0])
use3 = cards[1][0] + cards[1][1] + cards[1][2]
maximum = dmg[j]
if use1 > 0:
maximum = max(maximum, dmg[j - 1] + calc_dmg(j, [use1]))
if j == 1:
maximum = max(maximum, use1)
if use2 > 0:
maximum = max(maximum, dmg[j - 2] +
calc_dmg(j, [cards[1][0], cards[1][1]]
if cards[1][0] + cards[1][1] == use2
else [cards[1][0], cards[2][0]]))
if j == 2:
maximum = max(maximum, use2)
if use3 > 0:
maximum = max(maximum, dmg[j - 3] +
calc_dmg(j, [cards[1][0], cards[1][1], cards[1][2]]))
if j == 3:
maximum = max(maximum, use3)
new_dmg.append(maximum)
dmg = new_dmg
log(dmg)
print(max(dmg))
if DEBUG:
pr.disable()
pr.print_stats()
``` | vfc_26745 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1176/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n3\n1 6\n1 7\n1 5\n2\n1 4\n1 3\n3\n1 10\n3 5\n2 3\n3\n1 15\n2 4\n1 10\n1\n1 100\n",
"output": "263\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n3\n1 1\n1 1\n1 1\n3\n1 1\n1 1\n1 1\n3\n1 1\n1 1\n1 1\n3\n1 1\n1 1\n1 1\n3\n1 100\n1 1\n1 1\n",
"output": "211\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n4\n1 1\n1 1\n2 2\n3 4\n",
"output": "4\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4513 | Solve the following coding problem using the programming language python:
You are given a correct solution of the sudoku puzzle. If you don't know what is the sudoku, you can read about it here.
The picture showing the correct sudoku solution:
[Image]
Blocks are bordered with bold black color.
Your task is to change at most $9$ elements of this field (i.e. choose some $1 \le i, j \le 9$ and change the number at the position $(i, j)$ to any other number in range $[1; 9]$) to make it anti-sudoku. The anti-sudoku is the $9 \times 9$ field, in which: Any number in this field is in range $[1; 9]$; each row contains at least two equal elements; each column contains at least two equal elements; each $3 \times 3$ block (you can read what is the block in the link above) contains at least two equal elements.
It is guaranteed that the answer exists.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 10^4$) — the number of test cases. Then $t$ test cases follow.
Each test case consists of $9$ lines, each line consists of $9$ characters from $1$ to $9$ without any whitespaces — the correct solution of the sudoku puzzle.
-----Output-----
For each test case, print the answer — the initial field with at most $9$ changed elements so that the obtained field is anti-sudoku. If there are several solutions, you can print any. It is guaranteed that the answer exists.
-----Example-----
Input
1
154873296
386592714
729641835
863725149
975314628
412968357
631457982
598236471
247189563
Output
154873396
336592714
729645835
863725145
979314628
412958357
631457992
998236471
247789563
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
for _ in range(9): print (input().replace('2','1'))
``` | vfc_26753 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1335/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "1\n154873296\n386592714\n729641835\n863725149\n975314628\n412968357\n631457982\n598236471\n247189563\n",
"output": "154873196\n386591714\n719641835\n863715149\n975314618\n411968357\n631457981\n598136471\n147189563\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4514 | Solve the following coding problem using the programming language python:
In this problem you will have to help Berland army with organizing their command delivery system.
There are $n$ officers in Berland army. The first officer is the commander of the army, and he does not have any superiors. Every other officer has exactly one direct superior. If officer $a$ is the direct superior of officer $b$, then we also can say that officer $b$ is a direct subordinate of officer $a$.
Officer $x$ is considered to be a subordinate (direct or indirect) of officer $y$ if one of the following conditions holds: officer $y$ is the direct superior of officer $x$; the direct superior of officer $x$ is a subordinate of officer $y$.
For example, on the picture below the subordinates of the officer $3$ are: $5, 6, 7, 8, 9$.
The structure of Berland army is organized in such a way that every officer, except for the commander, is a subordinate of the commander of the army.
Formally, let's represent Berland army as a tree consisting of $n$ vertices, in which vertex $u$ corresponds to officer $u$. The parent of vertex $u$ corresponds to the direct superior of officer $u$. The root (which has index $1$) corresponds to the commander of the army.
Berland War Ministry has ordered you to give answers on $q$ queries, the $i$-th query is given as $(u_i, k_i)$, where $u_i$ is some officer, and $k_i$ is a positive integer.
To process the $i$-th query imagine how a command from $u_i$ spreads to the subordinates of $u_i$. Typical DFS (depth first search) algorithm is used here.
Suppose the current officer is $a$ and he spreads a command. Officer $a$ chooses $b$ — one of his direct subordinates (i.e. a child in the tree) who has not received this command yet. If there are many such direct subordinates, then $a$ chooses the one having minimal index. Officer $a$ gives a command to officer $b$. Afterwards, $b$ uses exactly the same algorithm to spread the command to its subtree. After $b$ finishes spreading the command, officer $a$ chooses the next direct subordinate again (using the same strategy). When officer $a$ cannot choose any direct subordinate who still hasn't received this command, officer $a$ finishes spreading the command.
Let's look at the following example: [Image]
If officer $1$ spreads a command, officers receive it in the following order: $[1, 2, 3, 5 ,6, 8, 7, 9, 4]$.
If officer $3$ spreads a command, officers receive it in the following order: $[3, 5, 6, 8, 7, 9]$.
If officer $7$ spreads a command, officers receive it in the following order: $[7, 9]$.
If officer $9$ spreads a command, officers receive it in the following order: $[9]$.
To answer the $i$-th query $(u_i, k_i)$, construct a sequence which describes the order in which officers will receive the command if the $u_i$-th officer spreads it. Return the $k_i$-th element of the constructed list or -1 if there are fewer than $k_i$ elements in it.
You should process queries independently. A query doesn't affect the following queries.
-----Input-----
The first line of the input contains two integers $n$ and $q$ ($2 \le n \le 2 \cdot 10^5, 1 \le q \le 2 \cdot 10^5$) — the number of officers in Berland army and the number of queries.
The second line of the input contains $n - 1$ integers $p_2, p_3, \dots, p_n$ ($1 \le p_i < i$), where $p_i$ is the index of the direct superior of the officer having the index $i$. The commander has index $1$ and doesn't have any superiors.
The next $q$ lines describe the queries. The $i$-th query is given as a pair ($u_i, k_i$) ($1 \le u_i, k_i \le n$), where $u_i$ is the index of the officer which starts spreading a command, and $k_i$ is the index of the required officer in the command spreading sequence.
-----Output-----
Print $q$ numbers, where the $i$-th number is the officer at the position $k_i$ in the list which describes the order in which officers will receive the command if it starts spreading from officer $u_i$. Print "-1" if the number of officers which receive the command is less than $k_i$.
You should process queries independently. They do not affect each other.
-----Example-----
Input
9 6
1 1 1 3 5 3 5 7
3 1
1 5
3 4
7 3
1 8
1 9
Output
3
6
8
-1
9
4
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n, q = map(int, input().split())
par = [int(v)-1 for v in input().split()]
chs = [[] for i in range(n)]
for i, p in enumerate(par):
chs[p].append(i+1)
vis = [0 for _ in range(n)]
bel = [1 for _ in range(n)]
stack = [0]
order = [0]
while stack:
v = stack[-1]
if len(chs[v]) == vis[v]:
if v != 0:
bel[par[v-1]] += bel[v]
stack.pop()
continue
ch = chs[v][vis[v]]
vis[v] += 1
order.append(ch)
stack.append(ch)
FST = {}
for i, c in enumerate(order):
FST[c] = i
out = []
for _ in range(q):
u, k = map(lambda x: int(x) - 1, input().split())
if k >= bel[u]:
out.append(-1)
else:
out.append(order[FST[u] + k] + 1)
print('\n'.join(map(str, out)))
``` | vfc_26757 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1006/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "9 6\n1 1 1 3 5 3 5 7\n3 1\n1 5\n3 4\n7 3\n1 8\n1 9\n",
"output": "3\n6\n8\n-1\n9\n4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 1\n1\n1 1\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "13 12\n1 1 1 1 1 1 1 1 1 1 1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n",
"output": "1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4515 | Solve the following coding problem using the programming language python:
Polycarp has three sisters: Alice, Barbara, and Cerene. They're collecting coins. Currently, Alice has $a$ coins, Barbara has $b$ coins and Cerene has $c$ coins. Recently Polycarp has returned from the trip around the world and brought $n$ coins.
He wants to distribute all these $n$ coins between his sisters in such a way that the number of coins Alice has is equal to the number of coins Barbara has and is equal to the number of coins Cerene has. In other words, if Polycarp gives $A$ coins to Alice, $B$ coins to Barbara and $C$ coins to Cerene ($A+B+C=n$), then $a + A = b + B = c + C$.
Note that A, B or C (the number of coins Polycarp gives to Alice, Barbara and Cerene correspondingly) can be 0.
Your task is to find out if it is possible to distribute all $n$ coins between sisters in a way described above.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 10^4$) — the number of test cases.
The next $t$ lines describe test cases. Each test case is given on a new line and consists of four space-separated integers $a, b, c$ and $n$ ($1 \le a, b, c, n \le 10^8$) — the number of coins Alice has, the number of coins Barbara has, the number of coins Cerene has and the number of coins Polycarp has.
-----Output-----
For each test case, print "YES" if Polycarp can distribute all $n$ coins between his sisters and "NO" otherwise.
-----Example-----
Input
5
5 3 2 8
100 101 102 105
3 2 1 100000000
10 20 15 14
101 101 101 3
Output
YES
YES
NO
NO
YES
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
a = int(input())
for i in range(a):
a1, b, c, n = list(map(int, input().split()))
t = max(a1, b, c)
if ((a1 + b + c + n) % 3 == 0 and t <= (a1 + b + c + n)//3 ):
print('YES')
else:
print('NO')
``` | vfc_26761 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1294/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n5 3 2 8\n100 101 102 105\n3 2 1 100000000\n10 20 15 14\n101 101 101 3\n",
"output": "YES\nYES\nNO\nNO\nYES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1 1 1 1111\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n3 798 437 1804\n",
"output": "YES\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4516 | Solve the following coding problem using the programming language python:
Let's define $p_i(n)$ as the following permutation: $[i, 1, 2, \dots, i - 1, i + 1, \dots, n]$. This means that the $i$-th permutation is almost identity (i.e. which maps every element to itself) permutation but the element $i$ is on the first position. Examples: $p_1(4) = [1, 2, 3, 4]$; $p_2(4) = [2, 1, 3, 4]$; $p_3(4) = [3, 1, 2, 4]$; $p_4(4) = [4, 1, 2, 3]$.
You are given an array $x_1, x_2, \dots, x_m$ ($1 \le x_i \le n$).
Let $pos(p, val)$ be the position of the element $val$ in $p$. So, $pos(p_1(4), 3) = 3, pos(p_2(4), 2) = 1, pos(p_4(4), 4) = 1$.
Let's define a function $f(p) = \sum\limits_{i=1}^{m - 1} |pos(p, x_i) - pos(p, x_{i + 1})|$, where $|val|$ is the absolute value of $val$. This function means the sum of distances between adjacent elements of $x$ in $p$.
Your task is to calculate $f(p_1(n)), f(p_2(n)), \dots, f(p_n(n))$.
-----Input-----
The first line of the input contains two integers $n$ and $m$ ($2 \le n, m \le 2 \cdot 10^5$) — the number of elements in each permutation and the number of elements in $x$.
The second line of the input contains $m$ integers ($m$, not $n$) $x_1, x_2, \dots, x_m$ ($1 \le x_i \le n$), where $x_i$ is the $i$-th element of $x$. Elements of $x$ can repeat and appear in arbitrary order.
-----Output-----
Print $n$ integers: $f(p_1(n)), f(p_2(n)), \dots, f(p_n(n))$.
-----Examples-----
Input
4 4
1 2 3 4
Output
3 4 6 5
Input
5 5
2 1 5 3 5
Output
9 8 12 6 8
Input
2 10
1 2 1 1 2 2 2 2 2 2
Output
3 3
-----Note-----
Consider the first example:
$x = [1, 2, 3, 4]$, so for the permutation $p_1(4) = [1, 2, 3, 4]$ the answer is $|1 - 2| + |2 - 3| + |3 - 4| = 3$; for the permutation $p_2(4) = [2, 1, 3, 4]$ the answer is $|2 - 1| + |1 - 3| + |3 - 4| = 4$; for the permutation $p_3(4) = [3, 1, 2, 4]$ the answer is $|2 - 3| + |3 - 1| + |1 - 4| = 6$; for the permutation $p_4(4) = [4, 1, 2, 3]$ the answer is $|2 - 3| + |3 - 4| + |4 - 1| = 5$.
Consider the second example:
$x = [2, 1, 5, 3, 5]$, so for the permutation $p_1(5) = [1, 2, 3, 4, 5]$ the answer is $|2 - 1| + |1 - 5| + |5 - 3| + |3 - 5| = 9$; for the permutation $p_2(5) = [2, 1, 3, 4, 5]$ the answer is $|1 - 2| + |2 - 5| + |5 - 3| + |3 - 5| = 8$; for the permutation $p_3(5) = [3, 1, 2, 4, 5]$ the answer is $|3 - 2| + |2 - 5| + |5 - 1| + |1 - 5| = 12$; for the permutation $p_4(5) = [4, 1, 2, 3, 5]$ the answer is $|3 - 2| + |2 - 5| + |5 - 4| + |4 - 5| = 6$; for the permutation $p_5(5) = [5, 1, 2, 3, 4]$ the answer is $|3 - 2| + |2 - 1| + |1 - 4| + |4 - 1| = 8$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n, m = map(int, input().split())
x = list(map(int, input().split()))
foo = [0 for _ in range(2+n)]
for i in range(1, m) :
p, q = x[i-1], x[i]
if p == q : continue
r = min(p, q)
s = max(p, q)
foo[0] += abs(p-q)
foo[r] -= abs(p-q)
foo[r] += max(p, q) - 1
foo[r+1] -= max(p, q) - 1
foo[r+1] += abs(p-q)-1
foo[s] -= abs(p-q)-1
foo[s] += min(p, q)
foo[s+1] -= min(p, q)
foo[s+1] += abs(p-q)
foo[n+1] -= abs(p-q)
# print(p, q, foo)
for i in range(1,n+1) :
foo[i] += foo[i-1]
print(foo[i], end=' ')
print()
``` | vfc_26765 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1234/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 4\n1 2 3 4\n",
"output": "3 4 6 5 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 5\n2 1 5 3 5\n",
"output": "9 8 12 6 8 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 10\n1 2 1 1 2 2 2 2 2 2\n",
"output": "3 3 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4517 | Solve the following coding problem using the programming language python:
You are given a rooted tree consisting of $n$ vertices numbered from $1$ to $n$. The root of the tree is a vertex number $1$.
A tree is a connected undirected graph with $n-1$ edges.
You are given $m$ queries. The $i$-th query consists of the set of $k_i$ distinct vertices $v_i[1], v_i[2], \dots, v_i[k_i]$. Your task is to say if there is a path from the root to some vertex $u$ such that each of the given $k$ vertices is either belongs to this path or has the distance $1$ to some vertex of this path.
-----Input-----
The first line of the input contains two integers $n$ and $m$ ($2 \le n \le 2 \cdot 10^5$, $1 \le m \le 2 \cdot 10^5$) — the number of vertices in the tree and the number of queries.
Each of the next $n-1$ lines describes an edge of the tree. Edge $i$ is denoted by two integers $u_i$ and $v_i$, the labels of vertices it connects $(1 \le u_i, v_i \le n, u_i \ne v_i$).
It is guaranteed that the given edges form a tree.
The next $m$ lines describe queries. The $i$-th line describes the $i$-th query and starts with the integer $k_i$ ($1 \le k_i \le n$) — the number of vertices in the current query. Then $k_i$ integers follow: $v_i[1], v_i[2], \dots, v_i[k_i]$ ($1 \le v_i[j] \le n$), where $v_i[j]$ is the $j$-th vertex of the $i$-th query.
It is guaranteed that all vertices in a single query are distinct.
It is guaranteed that the sum of $k_i$ does not exceed $2 \cdot 10^5$ ($\sum\limits_{i=1}^{m} k_i \le 2 \cdot 10^5$).
-----Output-----
For each query, print the answer — "YES", if there is a path from the root to some vertex $u$ such that each of the given $k$ vertices is either belongs to this path or has the distance $1$ to some vertex of this path and "NO" otherwise.
-----Example-----
Input
10 6
1 2
1 3
1 4
2 5
2 6
3 7
7 8
7 9
9 10
4 3 8 9 10
3 2 4 6
3 2 1 5
3 4 8 2
2 6 10
3 5 4 7
Output
YES
YES
YES
YES
NO
NO
-----Note-----
The picture corresponding to the example:
[Image]
Consider the queries.
The first query is $[3, 8, 9, 10]$. The answer is "YES" as you can choose the path from the root $1$ to the vertex $u=10$. Then vertices $[3, 9, 10]$ belong to the path from $1$ to $10$ and the vertex $8$ has distance $1$ to the vertex $7$ which also belongs to this path.
The second query is $[2, 4, 6]$. The answer is "YES" as you can choose the path to the vertex $u=2$. Then the vertex $4$ has distance $1$ to the vertex $1$ which belongs to this path and the vertex $6$ has distance $1$ to the vertex $2$ which belongs to this path.
The third query is $[2, 1, 5]$. The answer is "YES" as you can choose the path to the vertex $u=5$ and all vertices of the query belong to this path.
The fourth query is $[4, 8, 2]$. The answer is "YES" as you can choose the path to the vertex $u=9$ so vertices $2$ and $4$ both have distance $1$ to the vertex $1$ which belongs to this path and the vertex $8$ has distance $1$ to the vertex $7$ which belongs to this path.
The fifth and the sixth queries both have answer "NO" because you cannot choose suitable vertex $u$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
input = lambda: sys.stdin.readline().rstrip()
N, M = list(map(int, input().split()))
X = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
X[x].append(y)
X[y].append(x)
P = [-1] * N
DE = [0] * N
def EulerTour(n, X, i0 = 0):
Q = [~i0, i0]
ct = -1
ET = []
ET1 = [0] * n
ET2 = [0] * n
de = -1
while Q:
i = Q.pop()
if i < 0:
ET2[~i] = ct
de -= 1
continue
if i >= 0:
ET.append(i)
ct += 1
if ET1[i] == 0: ET1[i] = ct
de += 1
DE[i] = de
for a in X[i][::-1]:
if a != P[i]:
P[a] = i
for k in range(len(X[a])):
if X[a][k] == i:
del X[a][k]
break
Q.append(~a)
Q.append(a)
return (ET, ET1, ET2)
ET, ET1, ET2 = EulerTour(N, X, 0)
for _ in range(M):
A = [max(P[int(a) - 1], 0) for a in input().split()][1:]
mad = -1
for a in A:
if DE[a] > mad:
mad = DE[a]
maa = a
e = ET1[maa]
for a in A:
if not (ET1[a] <= e <= ET2[a]):
print("NO")
break
else:
print("YES")
``` | vfc_26769 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1328/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "10 6\n1 2\n1 3\n1 4\n2 5\n2 6\n3 7\n7 8\n7 9\n9 10\n4 3 8 9 10\n3 2 4 6\n3 2 1 5\n3 4 8 2\n2 6 10\n3 5 4 7\n",
"output": "YES\nYES\nYES\nYES\nNO\nNO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 3\n1 2\n1 1\n1 2\n2 1 2\n",
"output": "YES\nYES\nYES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 7\n1 2\n2 3\n1 1\n1 2\n1 3\n2 1 2\n2 1 3\n2 2 3\n3 1 2 3\n",
"output": "YES\nYES\nYES\nYES\nYES\nYES\nYES\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4518 | Solve the following coding problem using the programming language python:
There are $n$ districts in the town, the $i$-th district belongs to the $a_i$-th bandit gang. Initially, no districts are connected to each other.
You are the mayor of the city and want to build $n-1$ two-way roads to connect all districts (two districts can be connected directly or through other connected districts).
If two districts belonging to the same gang are connected directly with a road, this gang will revolt.
You don't want this so your task is to build $n-1$ two-way roads in such a way that all districts are reachable from each other (possibly, using intermediate districts) and each pair of directly connected districts belong to different gangs, or determine that it is impossible to build $n-1$ roads to satisfy all the conditions.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 500$) — the number of test cases. Then $t$ test cases follow.
The first line of the test case contains one integer $n$ ($2 \le n \le 5000$) — the number of districts. The second line of the test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le 10^9$), where $a_i$ is the gang the $i$-th district belongs to.
It is guaranteed that the sum of $n$ does not exceed $5000$ ($\sum n \le 5000$).
-----Output-----
For each test case, print:
NO on the only line if it is impossible to connect all districts satisfying the conditions from the problem statement. YES on the first line and $n-1$ roads on the next $n-1$ lines. Each road should be presented as a pair of integers $x_i$ and $y_i$ ($1 \le x_i, y_i \le n; x_i \ne y_i$), where $x_i$ and $y_i$ are two districts the $i$-th road connects.
For each road $i$, the condition $a[x_i] \ne a[y_i]$ should be satisfied. Also, all districts should be reachable from each other (possibly, using intermediate districts).
-----Example-----
Input
4
5
1 2 2 1 3
3
1 1 1
4
1 1000 101 1000
4
1 2 3 4
Output
YES
1 3
3 5
5 4
1 2
NO
YES
1 2
2 3
3 4
YES
1 2
1 3
1 4
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush,heappop
import math
from collections import *
from functools import reduce,cmp_to_key
import sys
input = sys.stdin.readline
M = mod = 998244353
def factors(n):return sorted(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
def inv_mod(n):return pow(n, mod - 2, mod)
def li():return [int(i) for i in input().rstrip('\n').split()]
def st():return input().rstrip('\n')
def val():return int(input().rstrip('\n'))
def li2():return [i for i in input().rstrip('\n')]
def li3():return [int(i) for i in input().rstrip('\n')]
for _ in range(val()):
n = val()
l = li()
if max(l) == min(l):
print('NO')
continue
print('YES')
root = l[0]
same = set()
other = -1
for i in range(1, n):
if l[i] == root:
same.add(i)
else:
other = i
print(1, i + 1)
for i in same:
print(i + 1, other + 1)
``` | vfc_26773 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1433/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n5\n1 2 2 1 3\n3\n1 1 1\n4\n1 1000 101 1000\n4\n1 2 3 4\n",
"output": "YES\n1 2\n1 3\n1 5\n5 4\nNO\nYES\n1 2\n1 3\n1 4\nYES\n1 2\n1 3\n1 4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n5\n6756657 32231 86 234 23442\n",
"output": "YES\n1 2\n1 3\n1 4\n1 5\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n2\n7 7\n",
"output": "NO\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4519 | Solve the following coding problem using the programming language python:
You are given a binary string of length $n$ (i. e. a string consisting of $n$ characters '0' and '1').
In one move you can swap two adjacent characters of the string. What is the lexicographically minimum possible string you can obtain from the given one if you can perform no more than $k$ moves? It is possible that you do not perform any moves at all.
Note that you can swap the same pair of adjacent characters with indices $i$ and $i+1$ arbitrary (possibly, zero) number of times. Each such swap is considered a separate move.
You have to answer $q$ independent test cases.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 10^4$) — the number of test cases.
The first line of the test case contains two integers $n$ and $k$ ($1 \le n \le 10^6, 1 \le k \le n^2$) — the length of the string and the number of moves you can perform.
The second line of the test case contains one string consisting of $n$ characters '0' and '1'.
It is guaranteed that the sum of $n$ over all test cases does not exceed $10^6$ ($\sum n \le 10^6$).
-----Output-----
For each test case, print the answer on it: the lexicographically minimum possible string of length $n$ you can obtain from the given one if you can perform no more than $k$ moves.
-----Example-----
Input
3
8 5
11011010
7 9
1111100
7 11
1111100
Output
01011110
0101111
0011111
-----Note-----
In the first example, you can change the string as follows: $1\underline{10}11010 \rightarrow \underline{10}111010 \rightarrow 0111\underline{10}10 \rightarrow 011\underline{10}110 \rightarrow 01\underline{10}1110 \rightarrow 01011110$.
In the third example, there are enough operations to make the string sorted.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
q=int(input())
for t in range(q):
n,k=map(int,input().split())
a=input()
ko=0
used=[0]*n
ans=''
g=True
for i in range(n):
if a[i]=='1':
ko+=1
else:
if ko<=k:
k-=ko
ans=ans+'0'
else:
for j in range(ko-k):
ans=ans+'1'
ans=ans+'0'
for j in range(k):
ans=ans+'1'
for j in range(i+1,n):
ans=ans+a[j]
print(ans)
g=False
break
if g==True:
for j in range(ko):
ans=ans+'1'
print(ans)
``` | vfc_26777 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1256/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n8 5\n11011010\n7 9\n1111100\n7 11\n1111100\n",
"output": "01011110\n0101111\n0011111\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n8 5\n11011010\n7 9\n1111100\n",
"output": "01011110\n0101111\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n2 1\n00\n",
"output": "00\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4520 | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions is constraints.
You are given $n$ segments on the coordinate axis $OX$. Segments can intersect, lie inside each other and even coincide. The $i$-th segment is $[l_i; r_i]$ ($l_i \le r_i$) and it covers all integer points $j$ such that $l_i \le j \le r_i$.
The integer point is called bad if it is covered by strictly more than $k$ segments.
Your task is to remove the minimum number of segments so that there are no bad points at all.
-----Input-----
The first line of the input contains two integers $n$ and $k$ ($1 \le k \le n \le 200$) — the number of segments and the maximum number of segments by which each integer point can be covered.
The next $n$ lines contain segments. The $i$-th line contains two integers $l_i$ and $r_i$ ($1 \le l_i \le r_i \le 200$) — the endpoints of the $i$-th segment.
-----Output-----
In the first line print one integer $m$ ($0 \le m \le n$) — the minimum number of segments you need to remove so that there are no bad points.
In the second line print $m$ distinct integers $p_1, p_2, \dots, p_m$ ($1 \le p_i \le n$) — indices of segments you remove in any order. If there are multiple answers, you can print any of them.
-----Examples-----
Input
7 2
11 11
9 11
7 8
8 9
7 8
9 11
7 9
Output
3
1 4 7
Input
5 1
29 30
30 30
29 29
28 30
30 30
Output
3
1 2 4
Input
6 1
2 3
3 3
2 3
2 2
2 3
2 3
Output
4
1 3 5 6
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from operator import itemgetter
import sys
input = sys.stdin.readline
n, m = map(int, input().split())
info = [list(map(int, input().split())) + [i] for i in range(n)]
info = sorted(info, key = itemgetter(1))
max_num = info[-1][1]
N = max_num
INF = 0
LV = (N-1).bit_length()
N0 = 2**LV
data = [0]*(2*N0)
lazy = [0]*(2*N0)
def gindex(l, r):
L = (l + N0) >> 1; R = (r + N0) >> 1
lc = 0 if l & 1 else (L & -L).bit_length()
rc = 0 if r & 1 else (R & -R).bit_length()
for i in range(LV):
if rc <= i:
yield R
if L < R and lc <= i:
yield L
L >>= 1; R >>= 1
def propagates(*ids):
for i in reversed(ids):
v = lazy[i-1]
if not v:
continue
lazy[2*i-1] += v; lazy[2*i] += v
data[2*i-1] += v; data[2*i] += v
lazy[i-1] = 0
def update(l, r, x):
*ids, = gindex(l, r)
propagates(*ids)
L = N0 + l; R = N0 + r
while L < R:
if R & 1:
R -= 1
lazy[R-1] += x; data[R-1] += x
if L & 1:
lazy[L-1] += x; data[L-1] += x
L += 1
L >>= 1; R >>= 1
for i in ids:
data[i-1] = max(data[2*i-1], data[2*i])
def query(l, r):
propagates(*gindex(l, r))
L = N0 + l; R = N0 + r
s = INF
while L < R:
if R & 1:
R -= 1
s = max(s, data[R-1])
if L & 1:
s = max(s, data[L-1])
L += 1
L >>= 1; R >>= 1
return s
ans = []
for i in range(n):
l, r, j = info[i]
r += 1
if query(l, r) < m:
update(l, r, 1)
else:
ans.append(j+1)
print(len(ans))
print(*ans)
``` | vfc_26781 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1249/D1",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7 2\n11 11\n9 11\n7 8\n8 9\n7 8\n9 11\n7 9\n",
"output": "3\n1 4 7 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4521 | Solve the following coding problem using the programming language python:
There are $n$ points on a coordinate axis $OX$. The $i$-th point is located at the integer point $x_i$ and has a speed $v_i$. It is guaranteed that no two points occupy the same coordinate. All $n$ points move with the constant speed, the coordinate of the $i$-th point at the moment $t$ ($t$ can be non-integer) is calculated as $x_i + t \cdot v_i$.
Consider two points $i$ and $j$. Let $d(i, j)$ be the minimum possible distance between these two points over any possible moments of time (even non-integer). It means that if two points $i$ and $j$ coincide at some moment, the value $d(i, j)$ will be $0$.
Your task is to calculate the value $\sum\limits_{1 \le i < j \le n}$ $d(i, j)$ (the sum of minimum distances over all pairs of points).
-----Input-----
The first line of the input contains one integer $n$ ($2 \le n \le 2 \cdot 10^5$) — the number of points.
The second line of the input contains $n$ integers $x_1, x_2, \dots, x_n$ ($1 \le x_i \le 10^8$), where $x_i$ is the initial coordinate of the $i$-th point. It is guaranteed that all $x_i$ are distinct.
The third line of the input contains $n$ integers $v_1, v_2, \dots, v_n$ ($-10^8 \le v_i \le 10^8$), where $v_i$ is the speed of the $i$-th point.
-----Output-----
Print one integer — the value $\sum\limits_{1 \le i < j \le n}$ $d(i, j)$ (the sum of minimum distances over all pairs of points).
-----Examples-----
Input
3
1 3 2
-100 2 3
Output
3
Input
5
2 1 4 3 5
2 2 2 3 4
Output
19
Input
2
2 1
-3 0
Output
0
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def bitadd(a,w,bit):
x = a
while x <= (len(bit)-1):
bit[x] += w
x += x & (-1 * x)
def bitsum(a,bit):
ret = 0
x = a
while x > 0:
ret += bit[x]
x -= x & (-1 * x)
return ret
n = int(input())
x = list(map(int,input().split()))
v = list(map(int,input().split()))
vlis = []
for i in v:
vlis.append(i)
vlis.sort()
vdic = {}
for i in range(n):
vdic[vlis[i]] = i+1
#print (vdic)
xv = []
for i in range(n):
xv.append([x[i],v[i]])
xv.sort()
ans = 0
BIT = [0] * (n+1)
BIT2 = [0] * (n+1)
for i in range(n):
x,v = xv[i]
ans += x * bitsum(vdic[v],BIT2) - bitsum(vdic[v],BIT)
bitadd(vdic[v] , x , BIT)
bitadd(vdic[v] , 1 , BIT2)
print (ans)
``` | vfc_26785 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1311/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n1 3 2\n-100 2 3\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n2 1 4 3 5\n2 2 2 3 4\n",
"output": "19\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n2 1\n-3 0\n",
"output": "0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4523 | Solve the following coding problem using the programming language python:
You are given the array $a$ consisting of $n$ positive (greater than zero) integers.
In one move, you can choose two indices $i$ and $j$ ($i \ne j$) such that the absolute difference between $a_i$ and $a_j$ is no more than one ($|a_i - a_j| \le 1$) and remove the smallest of these two elements. If two elements are equal, you can remove any of them (but exactly one).
Your task is to find if it is possible to obtain the array consisting of only one element using several (possibly, zero) such moves or not.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 1000$) — the number of test cases. Then $t$ test cases follow.
The first line of the test case contains one integer $n$ ($1 \le n \le 50$) — the length of $a$. The second line of the test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 100$), where $a_i$ is the $i$-th element of $a$.
-----Output-----
For each test case, print the answer: "YES" if it is possible to obtain the array consisting of only one element using several (possibly, zero) moves described in the problem statement, or "NO" otherwise.
-----Example-----
Input
5
3
1 2 2
4
5 5 5 5
3
1 2 4
4
1 3 4 4
1
100
Output
YES
YES
NO
NO
YES
-----Note-----
In the first test case of the example, we can perform the following sequence of moves: choose $i=1$ and $j=3$ and remove $a_i$ (so $a$ becomes $[2; 2]$); choose $i=1$ and $j=2$ and remove $a_j$ (so $a$ becomes $[2]$).
In the second test case of the example, we can choose any possible $i$ and $j$ any move and it doesn't matter which element we remove.
In the third test case of the example, there is no way to get rid of $2$ and $4$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
import math
def II():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
def MI():
return list(map(int, sys.stdin.readline().split()))
def SI():
return sys.stdin.readline().strip()
t = II()
for q in range(t):
n = II()
a = sorted(LI())
boo = True
for i in range(1,n):
if a[i]-a[i-1]>1:
boo = False
break
print("YES" if boo else "NO")
``` | vfc_26793 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1399/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n3\n1 2 2\n4\n5 5 5 5\n3\n1 2 4\n4\n1 3 4 4\n1\n100\n",
"output": "YES\nYES\nNO\nNO\nYES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n3\n1 2 2\n4\n5 5 5 5\n",
"output": "YES\nYES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n3\n1 2 3\n4\n1 2 3 4\n",
"output": "YES\nYES\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4524 | Solve the following coding problem using the programming language python:
You are given two huge binary integer numbers $a$ and $b$ of lengths $n$ and $m$ respectively. You will repeat the following process: if $b > 0$, then add to the answer the value $a~ \&~ b$ and divide $b$ by $2$ rounding down (i.e. remove the last digit of $b$), and repeat the process again, otherwise stop the process.
The value $a~ \&~ b$ means bitwise AND of $a$ and $b$. Your task is to calculate the answer modulo $998244353$.
Note that you should add the value $a~ \&~ b$ to the answer in decimal notation, not in binary. So your task is to calculate the answer in decimal notation. For example, if $a = 1010_2~ (10_{10})$ and $b = 1000_2~ (8_{10})$, then the value $a~ \&~ b$ will be equal to $8$, not to $1000$.
-----Input-----
The first line of the input contains two integers $n$ and $m$ ($1 \le n, m \le 2 \cdot 10^5$) — the length of $a$ and the length of $b$ correspondingly.
The second line of the input contains one huge integer $a$. It is guaranteed that this number consists of exactly $n$ zeroes and ones and the first digit is always $1$.
The third line of the input contains one huge integer $b$. It is guaranteed that this number consists of exactly $m$ zeroes and ones and the first digit is always $1$.
-----Output-----
Print the answer to this problem in decimal notation modulo $998244353$.
-----Examples-----
Input
4 4
1010
1101
Output
12
Input
4 5
1001
10101
Output
11
-----Note-----
The algorithm for the first example: add to the answer $1010_2~ \&~ 1101_2 = 1000_2 = 8_{10}$ and set $b := 110$; add to the answer $1010_2~ \&~ 110_2 = 10_2 = 2_{10}$ and set $b := 11$; add to the answer $1010_2~ \&~ 11_2 = 10_2 = 2_{10}$ and set $b := 1$; add to the answer $1010_2~ \&~ 1_2 = 0_2 = 0_{10}$ and set $b := 0$.
So the answer is $8 + 2 + 2 + 0 = 12$.
The algorithm for the second example: add to the answer $1001_2~ \&~ 10101_2 = 1_2 = 1_{10}$ and set $b := 1010$; add to the answer $1001_2~ \&~ 1010_2 = 1000_2 = 8_{10}$ and set $b := 101$; add to the answer $1001_2~ \&~ 101_2 = 1_2 = 1_{10}$ and set $b := 10$; add to the answer $1001_2~ \&~ 10_2 = 0_2 = 0_{10}$ and set $b := 1$; add to the answer $1001_2~ \&~ 1_2 = 1_2 = 1_{10}$ and set $b := 0$.
So the answer is $1 + 8 + 1 + 0 + 1 = 11$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def mi():
return list(map(int, input().split()))
'''
4 4
1010
1101
'''
n,m = mi()
a = list(input())
b = list(input())
pb = [0]*m
if b[0]=='1':
pb[0] = 1
for i in range(1,m):
if b[i]=='1':
pb[i] = 1
pb[i]+=pb[i-1]
ans = 0
if m>=n:
for i in range(n):
if a[i]=='1':
ans+=(pb[m-n+i]*pow(2,n-i-1,998244353))%998244353
ans%=998244353
print(ans%998244353)
else:
for i in range(n-m,n):
if a[i]=='1':
ans+=(pb[i-(n-m)]*pow(2,n-1-i,998244353))%998244353
ans%=998244353
print(ans%998244353)
``` | vfc_26797 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1066/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 4\n1010\n1101\n",
"output": "12\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 5\n1001\n10101\n",
"output": "11\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 5\n11111\n11111\n",
"output": "57\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4525 | Solve the following coding problem using the programming language python:
You are given a positive integer $n$, it is guaranteed that $n$ is even (i.e. divisible by $2$).
You want to construct the array $a$ of length $n$ such that: The first $\frac{n}{2}$ elements of $a$ are even (divisible by $2$); the second $\frac{n}{2}$ elements of $a$ are odd (not divisible by $2$); all elements of $a$ are distinct and positive; the sum of the first half equals to the sum of the second half ($\sum\limits_{i=1}^{\frac{n}{2}} a_i = \sum\limits_{i=\frac{n}{2} + 1}^{n} a_i$).
If there are multiple answers, you can print any. It is not guaranteed that the answer exists.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 10^4$) — the number of test cases. Then $t$ test cases follow.
The only line of the test case contains one integer $n$ ($2 \le n \le 2 \cdot 10^5$) — the length of the array. It is guaranteed that that $n$ is even (i.e. divisible by $2$).
It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$ ($\sum n \le 2 \cdot 10^5$).
-----Output-----
For each test case, print the answer — "NO" (without quotes), if there is no suitable answer for the given test case or "YES" in the first line and any suitable array $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^9$) satisfying conditions from the problem statement on the second line.
-----Example-----
Input
5
2
4
6
8
10
Output
NO
YES
2 4 1 5
NO
YES
2 4 6 8 1 3 5 11
NO
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n=int(input())
if(n%4!=0):
print('NO')
elif(n%4==0):
print('YES')
a=[]
for i in range(1,n//2+1):
a.append(i*2)
s=sum(a)
s1=0
for i in range(1,n//2):
x=i*2-1
a.append(x)
s1+=x
a.append(s-s1)
print(*a)
``` | vfc_26801 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1343/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n2\n4\n6\n8\n10\n",
"output": "NO\nYES\n2 4 1 5\nNO\nYES\n2 4 6 8 1 3 5 11\nNO\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4527 | Solve the following coding problem using the programming language python:
You are given $n$ segments on a coordinate axis $OX$. The $i$-th segment has borders $[l_i; r_i]$. All points $x$, for which $l_i \le x \le r_i$ holds, belong to the $i$-th segment.
Your task is to choose the maximum by size (the number of segments) subset of the given set of segments such that each pair of segments in this subset either non-intersecting or one of them lies inside the other one.
Two segments $[l_i; r_i]$ and $[l_j; r_j]$ are non-intersecting if they have no common points. For example, segments $[1; 2]$ and $[3; 4]$, $[1; 3]$ and $[5; 5]$ are non-intersecting, while segments $[1; 2]$ and $[2; 3]$, $[1; 2]$ and $[2; 2]$ are intersecting.
The segment $[l_i; r_i]$ lies inside the segment $[l_j; r_j]$ if $l_j \le l_i$ and $r_i \le r_j$. For example, segments $[2; 2]$, $[2, 3]$, $[3; 4]$ and $[2; 4]$ lie inside the segment $[2; 4]$, while $[2; 5]$ and $[1; 4]$ are not.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 1000$) — the number of test cases. Then $t$ test cases follow.
The first line of the test case contains one integer $n$ ($1 \le n \le 3000$) — the number of segments. The next $n$ lines describe segments. The $i$-th segment is given as two integers $l_i$ and $r_i$ ($1 \le l_i \le r_i \le 2 \cdot 10^5$), where $l_i$ is the left border of the $i$-th segment and $r_i$ is the right border of the $i$-th segment.
Additional constraint on the input: there are no duplicates in the list of segments.
It is guaranteed that the sum of $n$ does not exceed $3000$ ($\sum n \le 3000$).
-----Output-----
For each test case, print the answer: the maximum possible size of the subset of the given set of segments such that each pair of segments in this subset either non-intersecting or one of them lies inside the other one.
-----Example-----
Input
4
4
1 5
2 4
2 3
3 4
5
1 5
2 3
2 5
3 5
2 2
3
1 3
2 4
2 3
7
1 10
2 8
2 5
3 4
4 4
6 8
7 7
Output
3
4
2
7
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
from collections import deque
input=sys.stdin.readline
t=1
t=int(input())
for _ in range(t):
n=int(input())
val=set([0,2*10**5+1])
seg=[(0,2*10**5+1)]
for i in range(n):
l,r=list(map(int,input().split()))
val.add(l)
val.add(r)
seg.append((l,r))
val=list(val)
val.sort()
comp={i:e+1 for e,i in enumerate(val)}
for i in range(n+1):
l,r=seg[i]
seg[i]=(comp[l],comp[r])
deg=[0]*(n+1)
out=[[] for i in range(n+1)]
for i in range(n+1):
for j in range(i+1,n+1):
l,r=seg[i]
L,R=seg[j]
if L<=l and r<=R:
out[j].append(i)
deg[i]+=1
elif l<=L and R<=r:
out[i].append(j)
deg[j]+=1
ans=[0]
deq=deque(ans)
while deq:
v=deq.popleft()
for nv in out[v]:
deg[nv]-=1
if deg[nv]==0:
deq.append(nv)
ans.append(nv)
dp=[0]*(n+1)
def solve(v):
query=[[] for i in range(2*n+3)]
for nv in out[v]:
l,r=seg[nv]
query[r].append((l,dp[nv]))
subdp=[0]*(2*n+3)
for i in range(1,2*n+3):
res=subdp[i-1]
for l,val in query[i]:
test=subdp[l-1]+val
res=max(test,res)
subdp[i]=res
dp[v]=subdp[-1]+1
for v in ans[::-1]:
solve(v)
print(dp[0]-1)
``` | vfc_26809 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1399/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n4\n1 5\n2 4\n2 3\n3 4\n5\n1 5\n2 3\n2 5\n3 5\n2 2\n3\n1 3\n2 4\n2 3\n7\n1 10\n2 8\n2 5\n3 4\n4 4\n6 8\n7 7\n",
"output": "3\n4\n2\n7\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1\n1 200000\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1\n100000 100001\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4529 | Solve the following coding problem using the programming language python:
There is a robot on a coordinate plane. Initially, the robot is located at the point $(0, 0)$. Its path is described as a string $s$ of length $n$ consisting of characters 'L', 'R', 'U', 'D'.
Each of these characters corresponds to some move: 'L' (left): means that the robot moves from the point $(x, y)$ to the point $(x - 1, y)$; 'R' (right): means that the robot moves from the point $(x, y)$ to the point $(x + 1, y)$; 'U' (up): means that the robot moves from the point $(x, y)$ to the point $(x, y + 1)$; 'D' (down): means that the robot moves from the point $(x, y)$ to the point $(x, y - 1)$.
The company that created this robot asked you to optimize the path of the robot somehow. To do this, you can remove any non-empty substring of the path. But this company doesn't want their customers to notice the change in the robot behavior. It means that if before the optimization the robot ended its path at the point $(x_e, y_e)$, then after optimization (i.e. removing some single substring from $s$) the robot also ends its path at the point $(x_e, y_e)$.
This optimization is a low-budget project so you need to remove the shortest possible non-empty substring to optimize the robot's path such that the endpoint of his path doesn't change. It is possible that you can't optimize the path. Also, it is possible that after the optimization the target path is an empty string (i.e. deleted substring is the whole string $s$).
Recall that the substring of $s$ is such string that can be obtained from $s$ by removing some amount of characters (possibly, zero) from the prefix and some amount of characters (possibly, zero) from the suffix. For example, the substrings of "LURLLR" are "LU", "LR", "LURLLR", "URL", but not "RR" and "UL".
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 1000$) — the number of test cases.
The next $2t$ lines describe test cases. Each test case is given on two lines. The first line of the test case contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the length of the robot's path. The second line of the test case contains one string $s$ consisting of $n$ characters 'L', 'R', 'U', 'D' — the robot's path.
It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$ ($\sum n \le 2 \cdot 10^5$).
-----Output-----
For each test case, print the answer on it. If you cannot remove such non-empty substring that the endpoint of the robot's path doesn't change, print -1. Otherwise, print two integers $l$ and $r$ such that $1 \le l \le r \le n$ — endpoints of the substring you remove. The value $r-l+1$ should be minimum possible. If there are several answers, print any of them.
-----Example-----
Input
4
4
LRUD
4
LURD
5
RRUDU
5
LLDDR
Output
1 2
1 4
3 4
-1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n = int(input())
s = input()
balance = 0
index = {0: 1}
ans = [10**9]
i = 1
for x in s:
if x == 'U':
balance += 10 ** 9
elif x == 'D':
balance -= 10 ** 9
elif x == 'L':
balance += 1
else:
balance -= 1
if balance in index:
ans = min(ans, [i + 1 - index[balance], index[balance], i])
index[balance] = i + 1
i += 1
if ans[0] == 10 ** 9:
print(-1)
else:
print(ans[1], ans[2])
``` | vfc_26817 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1296/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n4\nLRUD\n4\nLURD\n5\nRRUDU\n5\nLLDDR\n",
"output": "1 2\n1 4\n3 4\n-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n10\nRULLDRRULD\n",
"output": "7 10\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n23\nRUURRDDLLUUURRRDDDLLLUD\n",
"output": "22 23\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4530 | Solve the following coding problem using the programming language python:
You have $n$ students under your control and you have to compose exactly two teams consisting of some subset of your students. Each student had his own skill, the $i$-th student skill is denoted by an integer $a_i$ (different students can have the same skills).
So, about the teams. Firstly, these two teams should have the same size. Two more constraints: The first team should consist of students with distinct skills (i.e. all skills in the first team are unique). The second team should consist of students with the same skills (i.e. all skills in the second team are equal).
Note that it is permissible that some student of the first team has the same skill as a student of the second team.
Consider some examples (skills are given): $[1, 2, 3]$, $[4, 4]$ is not a good pair of teams because sizes should be the same; $[1, 1, 2]$, $[3, 3, 3]$ is not a good pair of teams because the first team should not contain students with the same skills; $[1, 2, 3]$, $[3, 4, 4]$ is not a good pair of teams because the second team should contain students with the same skills; $[1, 2, 3]$, $[3, 3, 3]$ is a good pair of teams; $[5]$, $[6]$ is a good pair of teams.
Your task is to find the maximum possible size $x$ for which it is possible to compose a valid pair of teams, where each team size is $x$ (skills in the first team needed to be unique, skills in the second team should be the same between them). A student cannot be part of more than one team.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 10^4$) — the number of test cases. Then $t$ test cases follow.
The first line of the test case contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the number of students. The second line of the test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le n$), where $a_i$ is the skill of the $i$-th student. Different students can have the same skills.
It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$ ($\sum n \le 2 \cdot 10^5$).
-----Output-----
For each test case, print the answer — the maximum possible size $x$ for which it is possible to compose a valid pair of teams, where each team size is $x$.
-----Example-----
Input
4
7
4 2 4 1 4 3 4
5
2 1 5 4 3
1
1
4
1 1 1 3
Output
3
1
0
2
-----Note-----
In the first test case of the example, it is possible to construct two teams of size $3$: the first team is $[1, 2, 4]$ and the second team is $[4, 4, 4]$. Note, that there are some other ways to construct two valid teams of size $3$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from collections import defaultdict as dd
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
d=dd(int)
for i in a:
d[i]+=1
ma=0
r=len(d.keys())
for i in d.keys():
ma=max(ma,min(d[i]-1,r),min(d[i],r-1))
print(ma)
``` | vfc_26821 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1335/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n7\n4 2 4 1 4 3 4\n5\n2 1 5 4 3\n1\n1\n4\n1 1 1 3\n",
"output": "3\n1\n0\n2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n9\n1 2 2 3 3 9 9 9 9\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n",
"output": "0\n0\n0\n0\n0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4531 | Solve the following coding problem using the programming language python:
You are given a tree consisting exactly of $n$ vertices. Tree is a connected undirected graph with $n-1$ edges. Each vertex $v$ of this tree has a value $a_v$ assigned to it.
Let $dist(x, y)$ be the distance between the vertices $x$ and $y$. The distance between the vertices is the number of edges on the simple path between them.
Let's define the cost of the tree as the following value: firstly, let's fix some vertex of the tree. Let it be $v$. Then the cost of the tree is $\sum\limits_{i = 1}^{n} dist(i, v) \cdot a_i$.
Your task is to calculate the maximum possible cost of the tree if you can choose $v$ arbitrarily.
-----Input-----
The first line contains one integer $n$, the number of vertices in the tree ($1 \le n \le 2 \cdot 10^5$).
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 2 \cdot 10^5$), where $a_i$ is the value of the vertex $i$.
Each of the next $n - 1$ lines describes an edge of the tree. Edge $i$ is denoted by two integers $u_i$ and $v_i$, the labels of vertices it connects ($1 \le u_i, v_i \le n$, $u_i \ne v_i$).
It is guaranteed that the given edges form a tree.
-----Output-----
Print one integer — the maximum possible cost of the tree if you can choose any vertex as $v$.
-----Examples-----
Input
8
9 4 1 7 10 1 6 5
1 2
2 3
1 4
1 5
5 6
5 7
5 8
Output
121
Input
1
1337
Output
0
-----Note-----
Picture corresponding to the first example: [Image]
You can choose the vertex $3$ as a root, then the answer will be $2 \cdot 9 + 1 \cdot 4 + 0 \cdot 1 + 3 \cdot 7 + 3 \cdot 10 + 4 \cdot 1 + 4 \cdot 6 + 4 \cdot 5 = 18 + 4 + 0 + 21 + 30 + 4 + 24 + 20 = 121$.
In the second example tree consists only of one vertex so the answer is always $0$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import traceback
import sys
sys.setrecursionlimit(200010)
try:
# alpha = "abcdefghijklmnopqrstuvwxyz"
n = int(input())
a = [0]
a.extend(list(map(int, input().split())))
D = [[] for i in range(n+1)]
for i in range(n-1):
e1,e2 = (map(int, input().split()))
D[e1].append(e2)
D[e2].append(e1)
# for i in range(1,n+1):
# if i not in D:
# D[i] = []
visited = [False for i in range(n+1)]
cost = [a[i] for i in range(n+1)]
parent = [0 for i in range(n+1)]
val = 0
def dfs(s, depth):
nonlocal visited
nonlocal cost
nonlocal val
nonlocal a
nonlocal D
stack = [(s,depth)]
while stack:
s, depth = stack[-1]
if visited[s]:
stack.pop()
cost[parent[s]]+=cost[s]
continue
else:
visited[s] = True
val += depth*a[s]
for i in D[s]:
if not visited[i]:
parent[i] = s
stack.append((i, depth+1))
# cost[s]+=cost[i]
dfs(1, 0)
# ans = 1
max_cost = val
# print(max_cost)
visited = [False for i in range(n+1)]
cost[0] = sum(a)
def trav(s, some_val):
nonlocal cost
nonlocal visited
nonlocal max_cost
nonlocal D
stack = [(s,some_val)]
while stack:
s, some_val = stack.pop()
visited[s] = True
# print(some_val, s)
if some_val>max_cost:
max_cost = some_val
for i in D[s]:
if not visited[i]:
# print(i, some_val, cost[s], cost[i])
stack.append((i, some_val+(cost[0]-cost[i])-cost[i] ))
trav(1, val)
print(max_cost)
except Exception as ex:
traceback.print_tb(ex.__traceback__)
print(ex)
``` | vfc_26825 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1092/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "8\n9 4 1 7 10 1 6 5\n1 2\n2 3\n1 4\n1 5\n5 6\n5 7\n5 8\n",
"output": "121\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1337\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n12345 65432\n2 1\n",
"output": "65432\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4623 | Solve the following coding problem using the programming language python:
There are $n$ people who want to participate in a boat competition. The weight of the $i$-th participant is $w_i$. Only teams consisting of two people can participate in this competition. As an organizer, you think that it's fair to allow only teams with the same total weight.
So, if there are $k$ teams $(a_1, b_1)$, $(a_2, b_2)$, $\dots$, $(a_k, b_k)$, where $a_i$ is the weight of the first participant of the $i$-th team and $b_i$ is the weight of the second participant of the $i$-th team, then the condition $a_1 + b_1 = a_2 + b_2 = \dots = a_k + b_k = s$, where $s$ is the total weight of each team, should be satisfied.
Your task is to choose such $s$ that the number of teams people can create is the maximum possible. Note that each participant can be in no more than one team.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 1000$) — the number of test cases. Then $t$ test cases follow.
The first line of the test case contains one integer $n$ ($1 \le n \le 50$) — the number of participants. The second line of the test case contains $n$ integers $w_1, w_2, \dots, w_n$ ($1 \le w_i \le n$), where $w_i$ is the weight of the $i$-th participant.
-----Output-----
For each test case, print one integer $k$: the maximum number of teams people can compose with the total weight $s$, if you choose $s$ optimally.
-----Example-----
Input
5
5
1 2 3 4 5
8
6 6 6 6 6 6 8 8
8
1 2 2 1 2 1 1 2
3
1 3 3
6
1 1 3 4 2 2
Output
2
3
4
1
2
-----Note-----
In the first test case of the example, we can reach the optimal answer for $s=6$. Then the first boat is used by participants $1$ and $5$ and the second boat is used by participants $2$ and $4$ (indices are the same as weights).
In the second test case of the example, we can reach the optimal answer for $s=12$. Then first $6$ participants can form $3$ pairs.
In the third test case of the example, we can reach the optimal answer for $s=3$. The answer is $4$ because we have $4$ participants with weight $1$ and $4$ participants with weight $2$.
In the fourth test case of the example, we can reach the optimal answer for $s=4$ or $s=6$.
In the fifth test case of the example, we can reach the optimal answer for $s=3$. Note that participant with weight $3$ can't use the boat because there is no suitable pair for him in the list.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n = int(input())
wt = list(map(int, input().split()))
count = {}
for x in wt:
if x not in count:
count[x] = 0
count[x] += 1
k = 0
for s in range(101):
temp = 0
temp2 = 0
for x in count:
if (s - x) in count:
if (s - x) == x:
temp2 += count[x] // 2
else:
temp += min(count[x], count[s -x])
k = max(k, temp//2 + temp2)
print(k)
``` | vfc_27181 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1399/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n5\n1 2 3 4 5\n8\n6 6 6 6 6 6 8 8\n8\n1 2 2 1 2 1 1 2\n3\n1 3 3\n6\n1 1 3 4 2 2\n",
"output": "2\n3\n4\n1\n2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n14\n2 6 5 9 5 8 13 14 12 5 6 14 5 2\n36\n15 22 27 7 23 36 10 17 33 21 18 22 3 4 32 24 8 19 36 22 17 11 24 10 33 4 30 6 2 17 11 16 18 1 2 20\n2\n2 2\n12\n4 9 10 6 1 9 5 8 8 9 9 12\n",
"output": "3\n10\n1\n4\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4626 | Solve the following coding problem using the programming language python:
Three friends are going to meet each other. Initially, the first friend stays at the position $x = a$, the second friend stays at the position $x = b$ and the third friend stays at the position $x = c$ on the coordinate axis $Ox$.
In one minute each friend independently from other friends can change the position $x$ by $1$ to the left or by $1$ to the right (i.e. set $x := x - 1$ or $x := x + 1$) or even don't change it.
Let's introduce the total pairwise distance — the sum of distances between each pair of friends. Let $a'$, $b'$ and $c'$ be the final positions of the first, the second and the third friend, correspondingly. Then the total pairwise distance is $|a' - b'| + |a' - c'| + |b' - c'|$, where $|x|$ is the absolute value of $x$.
Friends are interested in the minimum total pairwise distance they can reach if they will move optimally. Each friend will move no more than once. So, more formally, they want to know the minimum total pairwise distance they can reach after one minute.
You have to answer $q$ independent test cases.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 1000$) — the number of test cases.
The next $q$ lines describe test cases. The $i$-th test case is given as three integers $a, b$ and $c$ ($1 \le a, b, c \le 10^9$) — initial positions of the first, second and third friend correspondingly. The positions of friends can be equal.
-----Output-----
For each test case print the answer on it — the minimum total pairwise distance (the minimum sum of distances between each pair of friends) if friends change their positions optimally. Each friend will move no more than once. So, more formally, you have to find the minimum total pairwise distance they can reach after one minute.
-----Example-----
Input
8
3 3 4
10 20 30
5 5 5
2 4 3
1 1000000000 1000000000
1 1000000000 999999999
3 2 5
3 2 6
Output
0
36
0
0
1999999994
1999999994
2
4
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t=int(input())
for nt in range(t):
a,b,c=map(int,input().split())
print (max(0,abs(a-b)+abs(b-c)+abs(a-c)-4))
``` | vfc_27193 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1272/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "8\n3 3 4\n10 20 30\n5 5 5\n2 4 3\n1 1000000000 1000000000\n1 1000000000 999999999\n3 2 5\n3 2 6\n",
"output": "0\n36\n0\n0\n1999999994\n1999999994\n2\n4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n1 1 1\n2 2 2\n3 3 3\n4 4 4\n10 5 8\n",
"output": "0\n0\n0\n0\n6\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4627 | Solve the following coding problem using the programming language python:
We call two numbers $x$ and $y$ similar if they have the same parity (the same remainder when divided by $2$), or if $|x-y|=1$. For example, in each of the pairs $(2, 6)$, $(4, 3)$, $(11, 7)$, the numbers are similar to each other, and in the pairs $(1, 4)$, $(3, 12)$, they are not.
You are given an array $a$ of $n$ ($n$ is even) positive integers. Check if there is such a partition of the array into pairs that each element of the array belongs to exactly one pair and the numbers in each pair are similar to each other.
For example, for the array $a = [11, 14, 16, 12]$, there is a partition into pairs $(11, 12)$ and $(14, 16)$. The numbers in the first pair are similar because they differ by one, and in the second pair because they are both even.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 1000$) — the number of test cases. Then $t$ test cases follow.
Each test case consists of two lines.
The first line contains an even positive integer $n$ ($2 \le n \le 50$) — length of array $a$.
The second line contains $n$ positive integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 100$).
-----Output-----
For each test case print: YES if the such a partition exists, NO otherwise.
The letters in the words YES and NO can be displayed in any case.
-----Example-----
Input
7
4
11 14 16 12
2
1 8
4
1 1 1 1
4
1 2 5 6
2
12 13
6
1 6 3 10 5 8
6
1 12 3 10 5 8
Output
YES
NO
YES
YES
YES
YES
NO
-----Note-----
The first test case was explained in the statement.
In the second test case, the two given numbers are not similar.
In the third test case, any partition is suitable.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def read_int():
return int(input())
def read_ints():
return list(map(int, input().split(' ')))
t = read_int()
for case_num in range(t):
n = read_int()
a = list(read_ints())
cnt = [0 for i in range(101)]
even = 0
for ai in a:
cnt[ai] += 1
if ai % 2 == 0:
even += 1
odd = n - even
if even % 2 == 0:
print('YES')
else:
ok = False
for i in range(1, 100):
if cnt[i] > 0 and cnt[i + 1] > 0:
ok = True
break
print('YES' if ok else 'NO')
``` | vfc_27197 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1360/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7\n4\n11 14 16 12\n2\n1 8\n4\n1 1 1 1\n4\n1 2 5 6\n2\n12 13\n6\n1 6 3 10 5 8\n6\n1 12 3 10 5 8\n",
"output": "YES\nNO\nYES\nYES\nYES\nYES\nNO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n4\n1 1 1 8\n",
"output": "NO\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4628 | Solve the following coding problem using the programming language python:
You are a mayor of Berlyatov. There are $n$ districts and $m$ two-way roads between them. The $i$-th road connects districts $x_i$ and $y_i$. The cost of travelling along this road is $w_i$. There is some path between each pair of districts, so the city is connected.
There are $k$ delivery routes in Berlyatov. The $i$-th route is going from the district $a_i$ to the district $b_i$. There is one courier on each route and the courier will always choose the cheapest (minimum by total cost) path from the district $a_i$ to the district $b_i$ to deliver products.
The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
You can make at most one road to have cost zero (i.e. you choose at most one road and change its cost with $0$).
Let $d(x, y)$ be the cheapest cost of travel between districts $x$ and $y$.
Your task is to find the minimum total courier routes cost you can achieve, if you optimally select the some road and change its cost with $0$. In other words, you have to find the minimum possible value of $\sum\limits_{i = 1}^{k} d(a_i, b_i)$ after applying the operation described above optimally.
-----Input-----
The first line of the input contains three integers $n$, $m$ and $k$ ($2 \le n \le 1000$; $n - 1 \le m \le min(1000, \frac{n(n-1)}{2})$; $1 \le k \le 1000$) — the number of districts, the number of roads and the number of courier routes.
The next $m$ lines describe roads. The $i$-th road is given as three integers $x_i$, $y_i$ and $w_i$ ($1 \le x_i, y_i \le n$; $x_i \ne y_i$; $1 \le w_i \le 1000$), where $x_i$ and $y_i$ are districts the $i$-th road connects and $w_i$ is its cost. It is guaranteed that there is some path between each pair of districts, so the city is connected. It is also guaranteed that there is at most one road between each pair of districts.
The next $k$ lines describe courier routes. The $i$-th route is given as two integers $a_i$ and $b_i$ ($1 \le a_i, b_i \le n$) — the districts of the $i$-th route. The route can go from the district to itself, some couriers routes can coincide (and you have to count them independently).
-----Output-----
Print one integer — the minimum total courier routes cost you can achieve (i.e. the minimum value $\sum\limits_{i=1}^{k} d(a_i, b_i)$, where $d(x, y)$ is the cheapest cost of travel between districts $x$ and $y$) if you can make some (at most one) road cost zero.
-----Examples-----
Input
6 5 2
1 2 5
2 3 7
2 4 4
4 5 2
4 6 8
1 6
5 3
Output
22
Input
5 5 4
1 2 5
2 3 4
1 4 3
4 3 7
3 5 2
1 5
1 3
3 3
1 5
Output
13
-----Note-----
The picture corresponding to the first example:
[Image]
There, you can choose either the road $(2, 4)$ or the road $(4, 6)$. Both options lead to the total cost $22$.
The picture corresponding to the second example:
$A$
There, you can choose the road $(3, 4)$. This leads to the total cost $13$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
input = sys.stdin.readline
import heapq
def dijkstra(n, s, edges):
hq = [(0, s)]
cost = [float('inf')] * n
cost[s] = 0
while hq:
c, v = heapq.heappop(hq)
if c > cost[v]:
continue
for d, u in edges[v]:
tmp = d + cost[v]
if tmp < cost[u]:
cost[u] = tmp
heapq.heappush(hq, (tmp, u))
return cost
def main():
n, m, k = map(int, input().split())
edges = [[] for _ in range(n)]
xy = []
for _ in range(m):
x, y, t = map(int,input().split())
x -= 1
y -= 1
edges[x].append((t, y))
edges[y].append((t, x))
xy.append((x, y))
dist = [[] for _ in range(n)]
for i in range(n):
dist[i] = dijkstra(n, i, edges)
ab = [list(map(int, input().split())) for _ in range(k)]
ans = 10 ** 20
for x, y in xy:
tmp = 0
for a, b in ab:
a -= 1
b -= 1
tmp += min(dist[a][b], dist[a][x] + dist[b][y], dist[a][y] + dist[b][x])
ans = min(ans, tmp)
print(ans)
main()
``` | vfc_27201 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1433/G",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6 5 2\n1 2 5\n2 3 7\n2 4 4\n4 5 2\n4 6 8\n1 6\n5 3\n",
"output": "22\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 5 4\n1 2 5\n2 3 4\n1 4 3\n4 3 7\n3 5 2\n1 5\n1 3\n3 3\n1 5\n",
"output": "13\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4629 | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions is the maximum value of $n$.
You are given a positive integer number $n$. You really love good numbers so you want to find the smallest good number greater than or equal to $n$.
The positive integer is called good if it can be represented as a sum of distinct powers of $3$ (i.e. no duplicates of powers of $3$ are allowed).
For example: $30$ is a good number: $30 = 3^3 + 3^1$, $1$ is a good number: $1 = 3^0$, $12$ is a good number: $12 = 3^2 + 3^1$, but $2$ is not a good number: you can't represent it as a sum of distinct powers of $3$ ($2 = 3^0 + 3^0$), $19$ is not a good number: you can't represent it as a sum of distinct powers of $3$ (for example, the representations $19 = 3^2 + 3^2 + 3^0 = 3^2 + 3^1 + 3^1 + 3^1 + 3^0$ are invalid), $20$ is also not a good number: you can't represent it as a sum of distinct powers of $3$ (for example, the representation $20 = 3^2 + 3^2 + 3^0 + 3^0$ is invalid).
Note, that there exist other representations of $19$ and $20$ as sums of powers of $3$ but none of them consists of distinct powers of $3$.
For the given positive integer $n$ find such smallest $m$ ($n \le m$) that $m$ is a good number.
You have to answer $q$ independent queries.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 500$) — the number of queries. Then $q$ queries follow.
The only line of the query contains one integer $n$ ($1 \le n \le 10^4$).
-----Output-----
For each query, print such smallest integer $m$ (where $n \le m$) that $m$ is a good number.
-----Example-----
Input
7
1
2
6
13
14
3620
10000
Output
1
3
9
13
27
6561
19683
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n = int(input())
bits = ['1']
while int(''.join(bits), 3) < n:
bits.append('1')
for i in range(len(bits)):
bits[i] = '0'
if int(''.join(bits), 3) < n:
bits[i] = '1'
print(int(''.join(bits), 3))
``` | vfc_27205 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1249/C1",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7\n1\n2\n6\n13\n14\n3620\n10000\n",
"output": "1\n3\n9\n13\n27\n6561\n19683\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "100\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32\n33\n34\n35\n36\n37\n38\n39\n40\n41\n42\n43\n44\n45\n46\n47\n48\n49\n50\n51\n52\n53\n54\n55\n56\n57\n58\n59\n60\n61\n62\n63\n64\n65\n66\n67\n68\n69\n70\n71\n72\n73\n74\n75\n76\n77\n78\n79\n80\n81\n82\n83\n84\n85\n86\n87\n88\n89\n90\n91\n92\n93\n94\n95\n96\n97\n98\n99\n100\n",
"output": "1\n3\n3\n4\n9\n9\n9\n9\n9\n10\n12\n12\n13\n27\n27\n27\n27\n27\n27\n27\n27\n27\n27\n27\n27\n27\n27\n28\n30\n30\n31\n36\n36\n36\n36\n36\n37\n39\n39\n40\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n81\n82\n84\n84\n85\n90\n90\n90\n90\n90\n91\n93\n93\n94\n108\n108\n108\n108\n108\n108\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4630 | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions is constraints.
There are $n$ kids, each of them is reading a unique book. At the end of any day, the $i$-th kid will give his book to the $p_i$-th kid (in case of $i = p_i$ the kid will give his book to himself). It is guaranteed that all values of $p_i$ are distinct integers from $1$ to $n$ (i.e. $p$ is a permutation). The sequence $p$ doesn't change from day to day, it is fixed.
For example, if $n=6$ and $p=[4, 6, 1, 3, 5, 2]$ then at the end of the first day the book of the $1$-st kid will belong to the $4$-th kid, the $2$-nd kid will belong to the $6$-th kid and so on. At the end of the second day the book of the $1$-st kid will belong to the $3$-th kid, the $2$-nd kid will belong to the $2$-th kid and so on.
Your task is to determine the number of the day the book of the $i$-th child is returned back to him for the first time for every $i$ from $1$ to $n$.
Consider the following example: $p = [5, 1, 2, 4, 3]$. The book of the $1$-st kid will be passed to the following kids: after the $1$-st day it will belong to the $5$-th kid, after the $2$-nd day it will belong to the $3$-rd kid, after the $3$-rd day it will belong to the $2$-nd kid, after the $4$-th day it will belong to the $1$-st kid.
So after the fourth day, the book of the first kid will return to its owner. The book of the fourth kid will return to him for the first time after exactly one day.
You have to answer $q$ independent queries.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 1000$) — the number of queries. Then $q$ queries follow.
The first line of the query contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the number of kids in the query. The second line of the query contains $n$ integers $p_1, p_2, \dots, p_n$ ($1 \le p_i \le n$, all $p_i$ are distinct, i.e. $p$ is a permutation), where $p_i$ is the kid which will get the book of the $i$-th kid.
It is guaranteed that $\sum n \le 2 \cdot 10^5$ (sum of $n$ over all queries does not exceed $2 \cdot 10^5$).
-----Output-----
For each query, print the answer on it: $n$ integers $a_1, a_2, \dots, a_n$, where $a_i$ is the number of the day the book of the $i$-th child is returned back to him for the first time in this query.
-----Example-----
Input
6
5
1 2 3 4 5
3
2 3 1
6
4 6 2 1 5 3
1
1
4
3 4 1 2
5
5 1 2 4 3
Output
1 1 1 1 1
3 3 3
2 3 3 2 1 3
1
2 2 2 2
4 4 4 1 4
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n = int(input())
P = list(map(int, input().split()))
ans = [0] * n
for i in range(n):
if ans[i] == 0:
now = i
cnt = 0
cll = []
while True:
now = P[now] - 1
cnt += 1
cll.append(now)
if now == i:
break
for u in cll:
ans[u] = cnt
print(' '.join(list(map(str, ans))))
``` | vfc_27209 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1249/B2",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6\n5\n1 2 3 4 5\n3\n2 3 1\n6\n4 6 2 1 5 3\n1\n1\n4\n3 4 1 2\n5\n5 1 2 4 3\n",
"output": "1 1 1 1 1 \n3 3 3 \n2 3 3 2 1 3 \n1 \n2 2 2 2 \n4 4 4 1 4 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "20\n6\n3 6 4 2 5 1\n6\n2 4 1 3 5 6\n7\n5 2 1 4 6 7 3\n6\n3 6 4 2 5 1\n9\n5 8 2 6 4 7 9 1 3\n9\n3 2 6 8 5 7 9 1 4\n8\n8 4 6 5 2 1 7 3\n5\n3 1 2 5 4\n10\n2 4 3 5 6 10 7 9 1 8\n2\n2 1\n1\n1\n5\n3 2 5 4 1\n3\n1 3 2\n8\n2 6 5 3 7 1 4 8\n5\n3 5 4 1 2\n4\n1 4 3 2\n5\n5 1 4 3 2\n4\n4 1 3 2\n1\n1\n7\n3 1 5 2 6 7 4\n",
"output": "5 5 5 5 1 5 \n4 4 4 4 1 1 \n5 1 5 1 5 5 5 \n5 5 5 5 1 5 \n9 9 9 9 9 9 9 9 9 \n7 1 7 7 1 7 7 7 7 \n4 3 4 3 3 4 1 4 \n3 3 3 2 2 \n8 8 1 8 8 8 1 8 8 8 \n2 2 \n1 \n3 1 3 1 3 \n1 2 2 \n3 3 4 4 4 3 4 1 \n3 2 3 3 2 \n1 2 1 2 \n3 3 2 2 3 \n3 3 1 3 \n1 \n7 7 7 7 7 7 7 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4631 | Solve the following coding problem using the programming language python:
There are $n$ Christmas trees on an infinite number line. The $i$-th tree grows at the position $x_i$. All $x_i$ are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are $m$ people who want to celebrate Christmas. Let $y_1, y_2, \dots, y_m$ be the positions of people (note that all values $x_1, x_2, \dots, x_n, y_1, y_2, \dots, y_m$ should be distinct and all $y_j$ should be integer). You want to find such an arrangement of people that the value $\sum\limits_{j=1}^{m}\min\limits_{i=1}^{n}|x_i - y_j|$ is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let $d_j$ be the distance from the $j$-th human to the nearest Christmas tree ($d_j = \min\limits_{i=1}^{n} |y_j - x_i|$). Then you need to choose such positions $y_1, y_2, \dots, y_m$ that $\sum\limits_{j=1}^{m} d_j$ is the minimum possible.
-----Input-----
The first line of the input contains two integers $n$ and $m$ ($1 \le n, m \le 2 \cdot 10^5$) — the number of Christmas trees and the number of people.
The second line of the input contains $n$ integers $x_1, x_2, \dots, x_n$ ($-10^9 \le x_i \le 10^9$), where $x_i$ is the position of the $i$-th Christmas tree. It is guaranteed that all $x_i$ are distinct.
-----Output-----
In the first line print one integer $res$ — the minimum possible value of $\sum\limits_{j=1}^{m}\min\limits_{i=1}^{n}|x_i - y_j|$ (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print $m$ integers $y_1, y_2, \dots, y_m$ ($-2 \cdot 10^9 \le y_j \le 2 \cdot 10^9$), where $y_j$ is the position of the $j$-th human. All $y_j$ should be distinct and all values $x_1, x_2, \dots, x_n, y_1, y_2, \dots, y_m$ should be distinct.
If there are multiple answers, print any of them.
-----Examples-----
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from queue import deque
n, m = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
used = set(arr)
q = deque()
for i in range(n):
q.append([arr[i] - 1, 1, -1])
q.append([arr[i] + 1, 1, 1])
ret = []
s = 0
while m:
x, l, dr = q.popleft()
a = x + dr
if not a in used:
q.append([a, l + 1, dr])
if not x in used:
used.add(x)
ret.append(x)
m -= 1
s += l
print(s)
print(*ret)
``` | vfc_27213 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1283/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2 6\n1 5\n",
"output": "8\n2 3 -1 0 6 4 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 5\n0 3 1\n",
"output": "7\n5 2 4 -1 -2 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4632 | Solve the following coding problem using the programming language python:
There is a robot in a warehouse and $n$ packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point $(0, 0)$. The $i$-th package is at the point $(x_i, y_i)$. It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point $(0, 0)$ doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point $(x, y)$ to the point ($x + 1, y$) or to the point $(x, y + 1)$.
As we say above, the robot wants to collect all $n$ packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string $s$ of length $n$ is lexicographically less than the string $t$ of length $n$ if there is some index $1 \le j \le n$ that for all $i$ from $1$ to $j-1$ $s_i = t_i$ and $s_j < t_j$. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
-----Input-----
The first line of the input contains an integer $t$ ($1 \le t \le 100$) — the number of test cases. Then test cases follow.
The first line of a test case contains one integer $n$ ($1 \le n \le 1000$) — the number of packages.
The next $n$ lines contain descriptions of packages. The $i$-th package is given as two integers $x_i$ and $y_i$ ($0 \le x_i, y_i \le 1000$) — the $x$-coordinate of the package and the $y$-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point $(0, 0)$ doesn't contain a package.
The sum of all values $n$ over test cases in the test doesn't exceed $1000$.
-----Output-----
Print the answer for each test case.
If it is impossible to collect all $n$ packages in some order starting from ($0,0$), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path — a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
-----Example-----
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
-----Note-----
For the first test case in the example the optimal path RUUURRRRUU is shown below: [Image]
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
input = sys.stdin.readline
t = int(input())
out = []
for _ in range(t):
n = int(input())
pos = []
for __ in range(n):
pos.append(tuple(map(int, input().split())))
pos.sort()
currX = 0
currY = 0
s = ''
works = True
for x, y in pos:
if currX > x:
works = False
break
else:
s += 'R' * (x - currX)
currX = x
if currY > y:
works = False
break
else:
s += 'U' * (y - currY)
currY = y
if works:
out.append('YES')
out.append(s)
else:
out.append('NO')
print('\n'.join(out))
``` | vfc_27217 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1294/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n5\n1 3\n1 2\n3 3\n5 5\n4 3\n2\n1 0\n0 1\n1\n4 3\n",
"output": "YES\nRUUURRRRUU\nNO\nYES\nRRRRUUU\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4633 | Solve the following coding problem using the programming language python:
You are given a positive integer $n$. In one move, you can increase $n$ by one (i.e. make $n := n + 1$). Your task is to find the minimum number of moves you need to perform in order to make the sum of digits of $n$ be less than or equal to $s$.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 2 \cdot 10^4$) — the number of test cases. Then $t$ test cases follow.
The only line of the test case contains two integers $n$ and $s$ ($1 \le n \le 10^{18}$; $1 \le s \le 162$).
-----Output-----
For each test case, print the answer: the minimum number of moves you need to perform in order to make the sum of digits of $n$ be less than or equal to $s$.
-----Example-----
Input
5
2 1
1 1
500 4
217871987498122 10
100000000000000001 1
Output
8
0
500
2128012501878
899999999999999999
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
def read_int():
return int(sys.stdin.readline())
def read_ints():
return list(map(int, sys.stdin.readline().split(' ')))
t = read_int()
for case_num in range(t):
n, s = read_ints()
a = [0] + [int(i) for i in str(n)]
ds = sum(a)
cost = 0
idx = len(a) - 1
radix = 1
while ds > s:
if a[idx] > 0:
cost += (10 - a[idx]) * radix
ds -= a[idx]
a[idx] = 0
ds += 1
a[idx - 1] += 1
i = idx - 1
while a[i] >= 10:
a[i - 1] += 1
a[i] -= 10
ds -= 9
i -= 1
radix *= 10
idx -= 1
print(cost)
``` | vfc_27221 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1409/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n2 1\n1 1\n500 4\n217871987498122 10\n100000000000000001 1\n",
"output": "8\n0\n500\n2128012501878\n899999999999999999\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1000000000000000000 1\n",
"output": "0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4634 | Solve the following coding problem using the programming language python:
There is a bookshelf which can fit $n$ books. The $i$-th position of bookshelf is $a_i = 1$ if there is a book on this position and $a_i = 0$ otherwise. It is guaranteed that there is at least one book on the bookshelf.
In one move, you can choose some contiguous segment $[l; r]$ consisting of books (i.e. for each $i$ from $l$ to $r$ the condition $a_i = 1$ holds) and: Shift it to the right by $1$: move the book at index $i$ to $i + 1$ for all $l \le i \le r$. This move can be done only if $r+1 \le n$ and there is no book at the position $r+1$. Shift it to the left by $1$: move the book at index $i$ to $i-1$ for all $l \le i \le r$. This move can be done only if $l-1 \ge 1$ and there is no book at the position $l-1$.
Your task is to find the minimum number of moves required to collect all the books on the shelf as a contiguous (consecutive) segment (i.e. the segment without any gaps).
For example, for $a = [0, 0, 1, 0, 1]$ there is a gap between books ($a_4 = 0$ when $a_3 = 1$ and $a_5 = 1$), for $a = [1, 1, 0]$ there are no gaps between books and for $a = [0, 0,0]$ there are also no gaps between books.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 200$) — the number of test cases. Then $t$ test cases follow.
The first line of the test case contains one integer $n$ ($1 \le n \le 50$) — the number of places on a bookshelf. The second line of the test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($0 \le a_i \le 1$), where $a_i$ is $1$ if there is a book at this position and $0$ otherwise. It is guaranteed that there is at least one book on the bookshelf.
-----Output-----
For each test case, print one integer: the minimum number of moves required to collect all the books on the shelf as a contiguous (consecutive) segment (i.e. the segment without gaps).
-----Example-----
Input
5
7
0 0 1 0 1 0 1
3
1 0 0
5
1 1 0 0 1
6
1 0 0 0 0 1
5
1 1 0 1 1
Output
2
0
2
4
1
-----Note-----
In the first test case of the example, you can shift the segment $[3; 3]$ to the right and the segment $[4; 5]$ to the right. After all moves, the books form the contiguous segment $[5; 7]$. So the answer is $2$.
In the second test case of the example, you have nothing to do, all the books on the bookshelf form the contiguous segment already.
In the third test case of the example, you can shift the segment $[5; 5]$ to the left and then the segment $[4; 4]$ to the left again. After all moves, the books form the contiguous segment $[1; 3]$. So the answer is $2$.
In the fourth test case of the example, you can shift the segment $[1; 1]$ to the right, the segment $[2; 2]$ to the right, the segment $[6; 6]$ to the left and then the segment $[5; 5]$ to the left. After all moves, the books form the contiguous segment $[3; 4]$. So the answer is $4$.
In the fifth test case of the example, you can shift the segment $[1; 2]$ to the right. After all moves, the books form the contiguous segment $[2; 5]$. So the answer is $1$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n=int(input())
s=list(map(int,input().split()))
l=s.index(1)
r=n-s[::-1].index(1)
ans=0
for i in range(l,r):
ans+=1-s[i]
print(ans)
``` | vfc_27225 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1433/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n7\n0 0 1 0 1 0 1\n3\n1 0 0\n5\n1 1 0 0 1\n6\n1 0 0 0 0 1\n5\n1 1 0 1 1\n",
"output": "2\n0\n2\n4\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n8\n0 0 0 1 1 1 1 1\n",
"output": "0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4635 | Solve the following coding problem using the programming language python:
You are given two integers $n$ and $k$.
Your task is to construct such a string $s$ of length $n$ that for each $i$ from $1$ to $k$ there is at least one $i$-th letter of the Latin alphabet in this string (the first letter is 'a', the second is 'b' and so on) and there are no other letters except these. You have to maximize the minimal frequency of some letter (the frequency of a letter is the number of occurrences of this letter in a string). If there are several possible answers, you can print any.
You have to answer $t$ independent queries.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 100$) — the number of queries.
The next $t$ lines are contain queries, one per line. The $i$-th line contains two integers $n_i$ and $k_i$ ($1 \le n_i \le 100, 1 \le k_i \le min(n_i, 26)$) — the length of the string in the $i$-th query and the number of characters in the $i$-th query.
-----Output-----
Print $t$ lines. In the $i$-th line print the answer to the $i$-th query: any string $s_i$ satisfying the conditions in the problem statement with constraints from the $i$-th query.
-----Example-----
Input
3
7 3
4 4
6 2
Output
cbcacab
abcd
baabab
-----Note-----
In the first example query the maximum possible minimal frequency is $2$, it can be easily seen that the better answer doesn't exist. Other examples of correct answers: "cbcabba", "ccbbaaa" (any permutation of given answers is also correct).
In the second example query any permutation of first four letters is acceptable (the maximum minimal frequency is $1$).
In the third example query any permutation of the given answer is acceptable (the maximum minimal frequency is $3$).
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n = int(input())
for i in range(n):
l, ch = map(int, input().split())
for j in range(l):
print(chr(j % ch + ord('a')), end='')
print()
``` | vfc_27229 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1092/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n7 3\n4 4\n6 2\n",
"output": "abcabca\nabcd\nababab\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "66\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n",
"output": "a\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4637 | Solve the following coding problem using the programming language python:
You are given two arrays $a$ and $b$ both consisting of $n$ positive (greater than zero) integers. You are also given an integer $k$.
In one move, you can choose two indices $i$ and $j$ ($1 \le i, j \le n$) and swap $a_i$ and $b_j$ (i.e. $a_i$ becomes $b_j$ and vice versa). Note that $i$ and $j$ can be equal or different (in particular, swap $a_2$ with $b_2$ or swap $a_3$ and $b_9$ both are acceptable moves).
Your task is to find the maximum possible sum you can obtain in the array $a$ if you can do no more than (i.e. at most) $k$ such moves (swaps).
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 200$) — the number of test cases. Then $t$ test cases follow.
The first line of the test case contains two integers $n$ and $k$ ($1 \le n \le 30; 0 \le k \le n$) — the number of elements in $a$ and $b$ and the maximum number of moves you can do. The second line of the test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 30$), where $a_i$ is the $i$-th element of $a$. The third line of the test case contains $n$ integers $b_1, b_2, \dots, b_n$ ($1 \le b_i \le 30$), where $b_i$ is the $i$-th element of $b$.
-----Output-----
For each test case, print the answer — the maximum possible sum you can obtain in the array $a$ if you can do no more than (i.e. at most) $k$ swaps.
-----Example-----
Input
5
2 1
1 2
3 4
5 5
5 5 6 6 5
1 2 5 4 3
5 3
1 2 3 4 5
10 9 10 10 9
4 0
2 2 4 3
2 4 2 3
4 4
1 2 2 1
4 4 5 4
Output
6
27
39
11
17
-----Note-----
In the first test case of the example, you can swap $a_1 = 1$ and $b_2 = 4$, so $a=[4, 2]$ and $b=[3, 1]$.
In the second test case of the example, you don't need to swap anything.
In the third test case of the example, you can swap $a_1 = 1$ and $b_1 = 10$, $a_3 = 3$ and $b_3 = 10$ and $a_2 = 2$ and $b_4 = 10$, so $a=[10, 10, 10, 4, 5]$ and $b=[1, 9, 3, 2, 9]$.
In the fourth test case of the example, you cannot swap anything.
In the fifth test case of the example, you can swap arrays $a$ and $b$, so $a=[4, 4, 5, 4]$ and $b=[1, 2, 2, 1]$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
input = sys.stdin.readline
rInt = lambda: int(input())
mInt = lambda: list(map(int, input().split()))
rLis = lambda: list(map(int, input().split()))
t = int(input())
for _ in range(t):
n, k = mInt()
a = rLis()
b = rLis()
a.sort()
b.sort(reverse = True)
for i in range(k):
if a[i] < b[i]:
a[i] = b[i]
print(sum(a))
``` | vfc_27237 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1353/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n2 1\n1 2\n3 4\n5 5\n5 5 6 6 5\n1 2 5 4 3\n5 3\n1 2 3 4 5\n10 9 10 10 9\n4 0\n2 2 4 3\n2 4 2 3\n4 4\n1 2 2 1\n4 4 5 4\n",
"output": "6\n27\n39\n11\n17\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n6 1\n1 4 2 23 15 13\n5 6 4 1 15 24\n",
"output": "81\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4638 | Solve the following coding problem using the programming language python:
You are planning to buy an apartment in a $n$-floor building. The floors are numbered from $1$ to $n$ from the bottom to the top. At first for each floor you want to know the minimum total time to reach it from the first (the bottom) floor.
Let: $a_i$ for all $i$ from $1$ to $n-1$ be the time required to go from the $i$-th floor to the $(i+1)$-th one (and from the $(i+1)$-th to the $i$-th as well) using the stairs; $b_i$ for all $i$ from $1$ to $n-1$ be the time required to go from the $i$-th floor to the $(i+1)$-th one (and from the $(i+1)$-th to the $i$-th as well) using the elevator, also there is a value $c$ — time overhead for elevator usage (you need to wait for it, the elevator doors are too slow!).
In one move, you can go from the floor you are staying at $x$ to any floor $y$ ($x \ne y$) in two different ways: If you are using the stairs, just sum up the corresponding values of $a_i$. Formally, it will take $\sum\limits_{i=min(x, y)}^{max(x, y) - 1} a_i$ time units. If you are using the elevator, just sum up $c$ and the corresponding values of $b_i$. Formally, it will take $c + \sum\limits_{i=min(x, y)}^{max(x, y) - 1} b_i$ time units.
You can perform as many moves as you want (possibly zero).
So your task is for each $i$ to determine the minimum total time it takes to reach the $i$-th floor from the $1$-st (bottom) floor.
-----Input-----
The first line of the input contains two integers $n$ and $c$ ($2 \le n \le 2 \cdot 10^5, 1 \le c \le 1000$) — the number of floors in the building and the time overhead for the elevator rides.
The second line of the input contains $n - 1$ integers $a_1, a_2, \dots, a_{n-1}$ ($1 \le a_i \le 1000$), where $a_i$ is the time required to go from the $i$-th floor to the $(i+1)$-th one (and from the $(i+1)$-th to the $i$-th as well) using the stairs.
The third line of the input contains $n - 1$ integers $b_1, b_2, \dots, b_{n-1}$ ($1 \le b_i \le 1000$), where $b_i$ is the time required to go from the $i$-th floor to the $(i+1)$-th one (and from the $(i+1)$-th to the $i$-th as well) using the elevator.
-----Output-----
Print $n$ integers $t_1, t_2, \dots, t_n$, where $t_i$ is the minimum total time to reach the $i$-th floor from the first floor if you can perform as many moves as you want.
-----Examples-----
Input
10 2
7 6 18 6 16 18 1 17 17
6 9 3 10 9 1 10 1 5
Output
0 7 13 18 24 35 36 37 40 45
Input
10 1
3 2 3 1 3 3 1 4 1
1 2 3 4 4 1 2 1 3
Output
0 2 4 7 8 11 13 14 16 17
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n, c = list(map(int, input().split()))
a = [int(ai) for ai in input().split()]
b = [int(bi) for bi in input().split()]
dpa, dpb = [0] * n, [0] * n
dpa[1], dpb[1] = a[0], c + b[0]
for i in range(1, n - 1):
dpa[i + 1], dpb[i + 1] = min(dpa[i], dpb[i]) + a[i], min(dpa[i] + c, dpb[i]) + b[i]
print(*(min(dpa[i], dpb[i]) for i in range(n)))
``` | vfc_27241 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1249/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "10 2\n7 6 18 6 16 18 1 17 17\n6 9 3 10 9 1 10 1 5\n",
"output": "0 7 13 18 24 35 36 37 40 45 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10 1\n3 2 3 1 3 3 1 4 1\n1 2 3 4 4 1 2 1 3\n",
"output": "0 2 4 7 8 11 13 14 16 17 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4639 | Solve the following coding problem using the programming language python:
For the given integer $n$ ($n > 2$) let's write down all the strings of length $n$ which contain $n-2$ letters 'a' and two letters 'b' in lexicographical (alphabetical) order.
Recall that the string $s$ of length $n$ is lexicographically less than string $t$ of length $n$, if there exists such $i$ ($1 \le i \le n$), that $s_i < t_i$, and for any $j$ ($1 \le j < i$) $s_j = t_j$. The lexicographic comparison of strings is implemented by the operator < in modern programming languages.
For example, if $n=5$ the strings are (the order does matter): aaabb aabab aabba abaab ababa abbaa baaab baaba babaa bbaaa
It is easy to show that such a list of strings will contain exactly $\frac{n \cdot (n-1)}{2}$ strings.
You are given $n$ ($n > 2$) and $k$ ($1 \le k \le \frac{n \cdot (n-1)}{2}$). Print the $k$-th string from the list.
-----Input-----
The input contains one or more test cases.
The first line contains one integer $t$ ($1 \le t \le 10^4$) — the number of test cases in the test. Then $t$ test cases follow.
Each test case is written on the the separate line containing two integers $n$ and $k$ ($3 \le n \le 10^5, 1 \le k \le \min(2\cdot10^9, \frac{n \cdot (n-1)}{2})$.
The sum of values $n$ over all test cases in the test doesn't exceed $10^5$.
-----Output-----
For each test case print the $k$-th string from the list of all described above strings of length $n$. Strings in the list are sorted lexicographically (alphabetically).
-----Example-----
Input
7
5 1
5 2
5 8
5 10
3 1
3 2
20 100
Output
aaabb
aabab
baaba
bbaaa
abb
bab
aaaaabaaaaabaaaaaaaa
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
t = I()
for _ in range(t):
n,k = LI()
f = 1
p = 1
while f <= k:
f += p
p += 1
f -= p
p -= 2
k -= f
p = n-p
k = n-k
ans = "a"*(p-2)+"b"+"a"*(k-p+1)+"b"+"a"*(n-k-1)
print(ans)
return
#Solve
def __starting_point():
solve()
__starting_point()
``` | vfc_27245 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1328/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7\n5 1\n5 2\n5 8\n5 10\n3 1\n3 2\n20 100\n",
"output": "aaabb\naabab\nbaaba\nbbaaa\nabb\nbab\naaaaabaaaaabaaaaaaaa\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "7\n8 18\n19 11\n20 5\n15 19\n19 15\n20 6\n10 28\n",
"output": "abaaabaa\naaaaaaaaaaaaabaaaab\naaaaaaaaaaaaaaaababa\naaaaaaaabaabaaa\naaaaaaaaaaaaabbaaaa\naaaaaaaaaaaaaaaabbaa\naabbaaaaaa\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4640 | Solve the following coding problem using the programming language python:
There are $n$ points on a plane. The $i$-th point has coordinates $(x_i, y_i)$. You have two horizontal platforms, both of length $k$. Each platform can be placed anywhere on a plane but it should be placed horizontally (on the same $y$-coordinate) and have integer borders. If the left border of the platform is $(x, y)$ then the right border is $(x + k, y)$ and all points between borders (including borders) belong to the platform.
Note that platforms can share common points (overlap) and it is not necessary to place both platforms on the same $y$-coordinate.
When you place both platforms on a plane, all points start falling down decreasing their $y$-coordinate. If a point collides with some platform at some moment, the point stops and is saved. Points which never collide with any platform are lost.
Your task is to find the maximum number of points you can save if you place both platforms optimally.
You have to answer $t$ independent test cases.
For better understanding, please read the Note section below to see a picture for the first test case.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 2 \cdot 10^4$) — the number of test cases. Then $t$ test cases follow.
The first line of the test case contains two integers $n$ and $k$ ($1 \le n \le 2 \cdot 10^5$; $1 \le k \le 10^9$) — the number of points and the length of each platform, respectively. The second line of the test case contains $n$ integers $x_1, x_2, \dots, x_n$ ($1 \le x_i \le 10^9$), where $x_i$ is $x$-coordinate of the $i$-th point. The third line of the input contains $n$ integers $y_1, y_2, \dots, y_n$ ($1 \le y_i \le 10^9$), where $y_i$ is $y$-coordinate of the $i$-th point. All points are distinct (there is no pair $1 \le i < j \le n$ such that $x_i = x_j$ and $y_i = y_j$).
It is guaranteed that the sum of $n$ does not exceed $2 \cdot 10^5$ ($\sum n \le 2 \cdot 10^5$).
-----Output-----
For each test case, print the answer: the maximum number of points you can save if you place both platforms optimally.
-----Example-----
Input
4
7 1
1 5 2 3 1 5 4
1 3 6 7 2 5 4
1 1
1000000000
1000000000
5 10
10 7 5 15 8
20 199 192 219 1904
10 10
15 19 8 17 20 10 9 2 10 19
12 13 6 17 1 14 7 9 19 3
Output
6
1
5
10
-----Note-----
The picture corresponding to the first test case of the example:
[Image]
Blue dots represent the points, red segments represent the platforms. One of the possible ways is to place the first platform between points $(1, -1)$ and $(2, -1)$ and the second one between points $(4, 3)$ and $(5, 3)$. Vectors represent how the points will fall down. As you can see, the only point we can't save is the point $(3, 7)$ so it falls down infinitely and will be lost. It can be proven that we can't achieve better answer here. Also note that the point $(5, 3)$ doesn't fall at all because it is already on the platform.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import bisect
def solve(n,x_coords,y_coords,k,ans):
x_coords.sort()
dp = []
for i in range(n):
x = x_coords[i]
index = bisect.bisect(x_coords,x+k)-1
dp.append(index-i+1)
dp_max = []
for i in reversed(dp):
if not dp_max:
dp_max.append(i)
else:
dp_max.append(max(dp_max[-1],i))
dp_max.reverse()
max_val = 0
for i in range(n):
x = x_coords[i]
index = bisect.bisect(x_coords,x+k)-1
val = index-i+1
if index+1 < n:
val += dp_max[index+1]
max_val = max(max_val,val)
ans.append(str(max_val))
def main():
t = int(input())
ans = []
for i in range(t):
n,k = list(map(int,input().split()))
x_coords = list(map(int,input().split()))
y_coords = list(map(int,input().split()))
solve(n,x_coords,y_coords,k,ans)
print('\n'.join(ans))
main()
``` | vfc_27249 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1409/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n7 1\n1 5 2 3 1 5 4\n1 3 6 7 2 5 4\n1 1\n1000000000\n1000000000\n5 10\n10 7 5 15 8\n20 199 192 219 1904\n10 10\n15 19 8 17 20 10 9 2 10 19\n12 13 6 17 1 14 7 9 19 3\n",
"output": "6\n1\n5\n10\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n1 1000000000\n1\n123456\n1 1000000000\n21345\n987654321\n1 1000000000\n1000000000\n1000000000\n1 1000000000\n1000000000\n1\n",
"output": "1\n1\n1\n1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4641 | Solve the following coding problem using the programming language python:
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples: for the array $[0, 0, 1, 0, 2]$ MEX equals to $3$ because numbers $0, 1$ and $2$ are presented in the array and $3$ is the minimum non-negative integer not presented in the array; for the array $[1, 2, 3, 4]$ MEX equals to $0$ because $0$ is the minimum non-negative integer not presented in the array; for the array $[0, 1, 4, 3]$ MEX equals to $2$ because $2$ is the minimum non-negative integer not presented in the array.
You are given an empty array $a=[]$ (in other words, a zero-length array). You are also given a positive integer $x$.
You are also given $q$ queries. The $j$-th query consists of one integer $y_j$ and means that you have to append one element $y_j$ to the array. The array length increases by $1$ after a query.
In one move, you can choose any index $i$ and set $a_i := a_i + x$ or $a_i := a_i - x$ (i.e. increase or decrease any element of the array by $x$). The only restriction is that $a_i$ cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of $q$ queries (i.e. the $j$-th answer corresponds to the array of length $j$).
Operations are discarded before each query. I.e. the array $a$ after the $j$-th query equals to $[y_1, y_2, \dots, y_j]$.
-----Input-----
The first line of the input contains two integers $q, x$ ($1 \le q, x \le 4 \cdot 10^5$) — the number of queries and the value of $x$.
The next $q$ lines describe queries. The $j$-th query consists of one integer $y_j$ ($0 \le y_j \le 10^9$) and means that you have to append one element $y_j$ to the array.
-----Output-----
Print the answer to the initial problem after each query — for the query $j$ print the maximum value of MEX after first $j$ queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
-----Examples-----
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
-----Note-----
In the first example: After the first query, the array is $a=[0]$: you don't need to perform any operations, maximum possible MEX is $1$. After the second query, the array is $a=[0, 1]$: you don't need to perform any operations, maximum possible MEX is $2$. After the third query, the array is $a=[0, 1, 2]$: you don't need to perform any operations, maximum possible MEX is $3$. After the fourth query, the array is $a=[0, 1, 2, 2]$: you don't need to perform any operations, maximum possible MEX is $3$ (you can't make it greater with operations). After the fifth query, the array is $a=[0, 1, 2, 2, 0]$: you can perform $a[4] := a[4] + 3 = 3$. The array changes to be $a=[0, 1, 2, 2, 3]$. Now MEX is maximum possible and equals to $4$. After the sixth query, the array is $a=[0, 1, 2, 2, 0, 0]$: you can perform $a[4] := a[4] + 3 = 0 + 3 = 3$. The array changes to be $a=[0, 1, 2, 2, 3, 0]$. Now MEX is maximum possible and equals to $4$. After the seventh query, the array is $a=[0, 1, 2, 2, 0, 0, 10]$. You can perform the following operations: $a[3] := a[3] + 3 = 2 + 3 = 5$, $a[4] := a[4] + 3 = 0 + 3 = 3$, $a[5] := a[5] + 3 = 0 + 3 = 3$, $a[5] := a[5] + 3 = 3 + 3 = 6$, $a[6] := a[6] - 3 = 10 - 3 = 7$, $a[6] := a[6] - 3 = 7 - 3 = 4$. The resulting array will be $a=[0, 1, 2, 5, 3, 6, 4]$. Now MEX is maximum possible and equals to $7$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
from heapq import *
input = sys.stdin.readline
quer, m = list(map(int, input().split()))
vals = list(range(m))
q = []
for v in vals:
heappush(q, v)
out = []
for _ in range(quer):
nex = int(input()) % m
vals[nex] += m
heappush(q, vals[nex])
new = heappop(q)
while vals[new % m] != new:
new = heappop(q)
out.append(new)
heappush(q, new)
print('\n'.join(map(str,out)))
``` | vfc_27253 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1294/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7 3\n0\n1\n2\n2\n0\n0\n10\n",
"output": "1\n2\n3\n3\n4\n4\n7\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 3\n1\n2\n1\n2\n",
"output": "0\n0\n0\n0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4642 | Solve the following coding problem using the programming language python:
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
The array consists of $n$ distinct positive (greater than $0$) integers. The array contains two elements $x$ and $y$ (these elements are known for you) such that $x < y$. If you sort the array in increasing order (such that $a_1 < a_2 < \ldots < a_n$), differences between all adjacent (consecutive) elements are equal (i.e. $a_2 - a_1 = a_3 - a_2 = \ldots = a_n - a_{n-1})$.
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize $\max(a_1, a_2, \dots, a_n)$.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 100$) — the number of test cases. Then $t$ test cases follow.
The only line of the test case contains three integers $n$, $x$ and $y$ ($2 \le n \le 50$; $1 \le x < y \le 50$) — the length of the array and two elements that are present in the array, respectively.
-----Output-----
For each test case, print the answer: $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^9$), where $a_i$ is the $i$-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
-----Example-----
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def read_int():
return int(input())
def read_ints():
return list(map(int, input().split(' ')))
t = read_int()
for case_num in range(t):
n, x, y = read_ints()
d = y - x
for i in range(n - 1, 0, -1):
if d % i == 0:
d //= i
l = min(n - (i + 1), (x - 1) // d)
ans = [x - l * d + i * d for i in range(n)]
print(' '.join(map(str, ans)))
break
``` | vfc_27257 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1409/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n2 1 49\n5 20 50\n6 20 50\n5 3 8\n9 13 22\n",
"output": "1 49 \n10 20 30 40 50 \n20 26 32 38 44 50 \n3 8 13 18 23 \n1 4 7 10 13 16 19 22 25 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n2 1 49\n",
"output": "1 49 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4643 | Solve the following coding problem using the programming language python:
You are developing a new feature for the website which sells airline tickets: being able to sort tickets by price! You have already extracted the tickets' prices, so there's just the last step to be done...
You are given an array of integers. Sort it in non-descending order.
-----Input-----
The input consists of a single line of space-separated integers. The first number is n (1 ≤ n ≤ 10) — the size of the array. The following n numbers are the elements of the array (1 ≤ a_{i} ≤ 100).
-----Output-----
Output space-separated elements of the sorted array.
-----Example-----
Input
3 3 1 2
Output
1 2 3
-----Note-----
Remember, this is a very important feature, and you have to make sure the customers appreciate it!
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import time
import random
l = list(map(int, input().split()))
assert len(l) == l[0] + 1
l = l[1:]
l.sort()
v = [0 for i in range(10 ** 4)]
for i in range(4 * 10**5):
v[random.randrange(0, len(v))] = random.randrange(-1000, 1000)
print(' '.join(map(str, l)))
``` | vfc_27261 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/784/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 3 1 2\n",
"output": "1 2 3 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10 54 100 27 1 33 27 80 49 27 6\n",
"output": "1 6 27 27 27 33 49 54 80 100 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4644 | Solve the following coding problem using the programming language python:
You are given an array $a$ consisting of $n$ integers.
In one move, you can choose two indices $1 \le i, j \le n$ such that $i \ne j$ and set $a_i := a_j$. You can perform such moves any number of times (possibly, zero). You can choose different indices in different operations. The operation := is the operation of assignment (i.e. you choose $i$ and $j$ and replace $a_i$ with $a_j$).
Your task is to say if it is possible to obtain an array with an odd (not divisible by $2$) sum of elements.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 2000$) — the number of test cases.
The next $2t$ lines describe test cases. The first line of the test case contains one integer $n$ ($1 \le n \le 2000$) — the number of elements in $a$. The second line of the test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 2000$), where $a_i$ is the $i$-th element of $a$.
It is guaranteed that the sum of $n$ over all test cases does not exceed $2000$ ($\sum n \le 2000$).
-----Output-----
For each test case, print the answer on it — "YES" (without quotes) if it is possible to obtain the array with an odd sum of elements, and "NO" otherwise.
-----Example-----
Input
5
2
2 3
4
2 2 8 8
3
3 3 3
4
5 5 5 5
4
1 1 1 1
Output
YES
NO
YES
NO
NO
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n = int(input())
ar = list(map(int, input().split()))
a, b = 0, 0
for elem in ar:
if elem % 2 == 0:
a = 1
else:
b = 1
if sum(ar) % 2 == 1:
print('YES')
elif a == 1 == b:
print('YES')
else:
print('NO')
``` | vfc_27265 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1296/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n2\n2 3\n4\n2 2 8 8\n3\n3 3 3\n4\n5 5 5 5\n4\n1 1 1 1\n",
"output": "YES\nNO\nYES\nNO\nNO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1\n114\n",
"output": "NO\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4645 | Solve the following coding problem using the programming language python:
A permutation of length $n$ is an array $p=[p_1,p_2,\dots,p_n]$, which contains every integer from $1$ to $n$ (inclusive) and, moreover, each number appears exactly once. For example, $p=[3,1,4,2,5]$ is a permutation of length $5$.
For a given number $n$ ($n \ge 2$), find a permutation $p$ in which absolute difference (that is, the absolute value of difference) of any two neighboring (adjacent) elements is between $2$ and $4$, inclusive. Formally, find such permutation $p$ that $2 \le |p_i - p_{i+1}| \le 4$ for each $i$ ($1 \le i < n$).
Print any such permutation for the given integer $n$ or determine that it does not exist.
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 100$) — the number of test cases in the input. Then $t$ test cases follow.
Each test case is described by a single line containing an integer $n$ ($2 \le n \le 1000$).
-----Output-----
Print $t$ lines. Print a permutation that meets the given requirements. If there are several such permutations, then print any of them. If no such permutation exists, print -1.
-----Example-----
Input
6
10
2
4
6
7
13
Output
9 6 10 8 4 7 3 1 5 2
-1
3 1 4 2
5 3 6 2 4 1
5 1 3 6 2 4 7
13 9 7 11 8 4 1 3 5 2 6 10 12
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
T = int(input())
for _ in range(T):
n = int(input())
if n <= 3:
print(-1)
else:
left = []
for i in range(1, n + 1, 2):
left.append(i)
right = []
right.append(4)
right.append(2)
for i in range(6, n + 1, 2):
right.append(i)
right.reverse()
for i in left:
right.append(i)
for i in right:
print(i, end = " ")
print("")
``` | vfc_27269 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1352/G",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6\n10\n2\n4\n6\n7\n13\n",
"output": "2 4 1 3 6 8 5 9 7 10 \n-1\n2 4 1 3 \n2 4 1 5 3 6 \n2 4 1 5 7 3 6 \n2 4 1 3 6 8 5 7 10 12 9 13 11 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "7\n4\n3\n5\n4\n4\n4\n4\n",
"output": "2 4 1 3 \n-1\n2 4 1 5 3 \n2 4 1 3 \n2 4 1 3 \n2 4 1 3 \n2 4 1 3 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4646 | Solve the following coding problem using the programming language python:
You are given an array $a[0 \ldots n-1]$ of length $n$ which consists of non-negative integers. Note that array indices start from zero.
An array is called good if the parity of each index matches the parity of the element at that index. More formally, an array is good if for all $i$ ($0 \le i \le n - 1$) the equality $i \bmod 2 = a[i] \bmod 2$ holds, where $x \bmod 2$ is the remainder of dividing $x$ by 2.
For example, the arrays [$0, 5, 2, 1$] and [$0, 17, 0, 3$] are good, and the array [$2, 4, 6, 7$] is bad, because for $i=1$, the parities of $i$ and $a[i]$ are different: $i \bmod 2 = 1 \bmod 2 = 1$, but $a[i] \bmod 2 = 4 \bmod 2 = 0$.
In one move, you can take any two elements of the array and swap them (these elements are not necessarily adjacent).
Find the minimum number of moves in which you can make the array $a$ good, or say that this is not possible.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 1000$) — the number of test cases in the test. Then $t$ test cases follow.
Each test case starts with a line containing an integer $n$ ($1 \le n \le 40$) — the length of the array $a$.
The next line contains $n$ integers $a_0, a_1, \ldots, a_{n-1}$ ($0 \le a_i \le 1000$) — the initial array.
-----Output-----
For each test case, output a single integer — the minimum number of moves to make the given array $a$ good, or -1 if this is not possible.
-----Example-----
Input
4
4
3 2 7 6
3
3 2 6
1
7
7
4 9 2 1 18 3 0
Output
2
1
-1
0
-----Note-----
In the first test case, in the first move, you can swap the elements with indices $0$ and $1$, and in the second move, you can swap the elements with indices $2$ and $3$.
In the second test case, in the first move, you need to swap the elements with indices $0$ and $1$.
In the third test case, you cannot make the array good.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
od=0
ev=0
for i in range(n):
if(i&1):
if(a[i]%2==0):
od+=1
else:
if(a[i]&1):
ev+=1
if(od!=ev):
print(-1)
else:
print(od)
``` | vfc_27273 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1367/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n4\n3 2 7 6\n3\n3 2 6\n1\n7\n7\n4 9 2 1 18 3 0\n",
"output": "2\n1\n-1\n0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "7\n1\n0\n1\n0\n1\n0\n1\n0\n1\n0\n1\n0\n1\n0\n",
"output": "0\n0\n0\n0\n0\n0\n0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4648 | Solve the following coding problem using the programming language python:
You are given an integer $n$. In one move, you can either multiply $n$ by two or divide $n$ by $6$ (if it is divisible by $6$ without the remainder).
Your task is to find the minimum number of moves needed to obtain $1$ from $n$ or determine if it's impossible to do that.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 2 \cdot 10^4$) — the number of test cases. Then $t$ test cases follow.
The only line of the test case contains one integer $n$ ($1 \le n \le 10^9$).
-----Output-----
For each test case, print the answer — the minimum number of moves needed to obtain $1$ from $n$ if it's possible to do that or -1 if it's impossible to obtain $1$ from $n$.
-----Example-----
Input
7
1
2
3
12
12345
15116544
387420489
Output
0
-1
2
-1
-1
12
36
-----Note-----
Consider the sixth test case of the example. The answer can be obtained by the following sequence of moves from the given integer $15116544$:
Divide by $6$ and get $2519424$; divide by $6$ and get $419904$; divide by $6$ and get $69984$; divide by $6$ and get $11664$; multiply by $2$ and get $23328$; divide by $6$ and get $3888$; divide by $6$ and get $648$; divide by $6$ and get $108$; multiply by $2$ and get $216$; divide by $6$ and get $36$; divide by $6$ and get $6$; divide by $6$ and get $1$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for testcase in range(int(input())):
n = int(input())
cnt2, cnt3 = 0, 0
while n % 2 == 0:
n //= 2
cnt2 += 1
while n % 3 == 0:
n //= 3
cnt3 += 1
if n > 1 or cnt3 < cnt2:
print(-1)
continue
print(2 * cnt3 - cnt2)
``` | vfc_27281 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1374/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7\n1\n2\n3\n12\n12345\n15116544\n387420489\n",
"output": "0\n-1\n2\n-1\n-1\n12\n36\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n999838675\n",
"output": "-1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4649 | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions is the size of the input.
You are given a string $s$ consisting of $n$ characters, each character is 'R', 'G' or 'B'.
You are also given an integer $k$. Your task is to change the minimum number of characters in the initial string $s$ so that after the changes there will be a string of length $k$ that is a substring of $s$, and is also a substring of the infinite string "RGBRGBRGB ...".
A string $a$ is a substring of string $b$ if there exists a positive integer $i$ such that $a_1 = b_i$, $a_2 = b_{i + 1}$, $a_3 = b_{i + 2}$, ..., $a_{|a|} = b_{i + |a| - 1}$. For example, strings "GBRG", "B", "BR" are substrings of the infinite string "RGBRGBRGB ..." while "GR", "RGR" and "GGG" are not.
You have to answer $q$ independent queries.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 2000$) — the number of queries. Then $q$ queries follow.
The first line of the query contains two integers $n$ and $k$ ($1 \le k \le n \le 2000$) — the length of the string $s$ and the length of the substring.
The second line of the query contains a string $s$ consisting of $n$ characters 'R', 'G' and 'B'.
It is guaranteed that the sum of $n$ over all queries does not exceed $2000$ ($\sum n \le 2000$).
-----Output-----
For each query print one integer — the minimum number of characters you need to change in the initial string $s$ so that after changing there will be a substring of length $k$ in $s$ that is also a substring of the infinite string "RGBRGBRGB ...".
-----Example-----
Input
3
5 2
BGGGG
5 3
RBRGR
5 5
BBBRR
Output
1
0
3
-----Note-----
In the first example, you can change the first character to 'R' and obtain the substring "RG", or change the second character to 'R' and obtain "BR", or change the third, fourth or fifth character to 'B' and obtain "GB".
In the second example, the substring is "BRG".
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
def countR(ip):
c=0
for i in ip:
if(i=='R'):
c+=1
return c
def countB(ip):
c=0
for i in ip:
if(i=='B'):
c+=1
return c
def countG(ip):
c=0
for i in ip:
if(i=='G'):
c+=1
return c
# sys.stdin.readline()
t=int(sys.stdin.readline())
x='RGB'*680
y='GBR'*680
z='BRG'*680
for i in range(t):
n,k=list(map(int,sys.stdin.readline().strip().split()))
a=sys.stdin.readline().strip()
xk=x[:k]
yk=y[:k]
zk=z[:k]
# print(k,xk,zk)
# xc=[]
# yc=[]
# zc=[]
# xc.append(countR(xk))
# xc.append(countG(xk))
# xc.append(countB(xk))
# yc.append(countR(yk))
# yc.append(countG(yk))
# yc.append(countB(yk))
# zc.append(countR(zk))
# zc.append(countG(zk))
# zc.append(countB(zk))
op=2001
for j in range(n-k+1):
b=a[j:j+k]
# print(len(b),xc,zc)
# bc=[]
# bc.append(countR(b))
# bc.append(countG(b))
# bc.append(countB(b))
xd=0
yd=0
zd=0
# print(a,b,xc,yc,zc,bc)
for jj in range(len(b)):
if(b[jj]!=xk[jj]):
xd+=1
if(b[jj]!=yk[jj]):
yd+=1
if(b[jj]!=zk[jj]):
zd+=1
# print(a,b,xd,yd,zd,z)
op=min(op,xd,yd,zd)
print(op)
``` | vfc_27285 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1196/D1",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n5 2\nBGGGG\n5 3\nRBRGR\n5 5\nBBBRR\n",
"output": "1\n0\n3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n18 2\nRBGGGRBBGRRBBGGGGB\n",
"output": "0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4650 | Solve the following coding problem using the programming language python:
You are given an array $a$ consisting of $n$ integers $a_1, a_2, \dots , a_n$.
In one operation you can choose two elements of the array and replace them with the element equal to their sum (it does not matter where you insert the new element). For example, from the array $[2, 1, 4]$ you can obtain the following arrays: $[3, 4]$, $[1, 6]$ and $[2, 5]$.
Your task is to find the maximum possible number of elements divisible by $3$ that are in the array after performing this operation an arbitrary (possibly, zero) number of times.
You have to answer $t$ independent queries.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 1000$) — the number of queries.
The first line of each query contains one integer $n$ ($1 \le n \le 100$).
The second line of each query contains $n$ integers $a_1, a_2, \dots , a_n$ ($1 \le a_i \le 10^9$).
-----Output-----
For each query print one integer in a single line — the maximum possible number of elements divisible by $3$ that are in the array after performing described operation an arbitrary (possibly, zero) number of times.
-----Example-----
Input
2
5
3 1 2 3 1
7
1 1 1 1 1 2 2
Output
3
3
-----Note-----
In the first query of the example you can apply the following sequence of operations to obtain $3$ elements divisible by $3$: $[3, 1, 2, 3, 1] \rightarrow [3, 3, 3, 1]$.
In the second query you can obtain $3$ elements divisible by $3$ with the following sequence of operations: $[1, 1, 1, 1, 1, 2, 2] \rightarrow [1, 1, 1, 1, 2, 3] \rightarrow [1, 1, 1, 3, 3] \rightarrow [2, 1, 3, 3] \rightarrow [3, 3, 3]$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for i in range(int(input())):
n=int(input())
l1=list(map(int,input().split()))
type1=0
type2=0
ans=0
for item in l1:
if item%3==0:
ans+=1
elif item%3==1:
type1+=1
else :
type2+=1
x=min(type1,type2)
ans+=x
type1-=x
type2-=x
ans+=(type1//3+type2//3)
print(ans)
``` | vfc_27289 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1176/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n5\n3 1 2 3 1\n7\n1 1 1 1 1 2 2\n",
"output": "3\n3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n5\n3 3 3 3 3\n",
"output": "5\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4651 | Solve the following coding problem using the programming language python:
You are given a permutation of length $n$. Recall that the permutation is an array consisting of $n$ distinct integers from $1$ to $n$ in arbitrary order. For example, $[2, 3, 1, 5, 4]$ is a permutation, but $[1, 2, 2]$ is not a permutation ($2$ appears twice in the array) and $[1, 3, 4]$ is also not a permutation ($n=3$ but there is $4$ in the array).
You can perform at most $n-1$ operations with the given permutation (it is possible that you don't perform any operations at all). The $i$-th operation allows you to swap elements of the given permutation on positions $i$ and $i+1$. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer $q$ independent test cases.
For example, let's consider the permutation $[5, 4, 1, 3, 2]$. The minimum possible permutation we can obtain is $[1, 5, 2, 4, 3]$ and we can do it in the following way:
perform the second operation (swap the second and the third elements) and obtain the permutation $[5, 1, 4, 3, 2]$; perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation $[5, 1, 4, 2, 3]$; perform the third operation (swap the third and the fourth elements) and obtain the permutation $[5, 1, 2, 4, 3]$. perform the first operation (swap the first and the second elements) and obtain the permutation $[1, 5, 2, 4, 3]$;
Another example is $[1, 2, 4, 3]$. The minimum possible permutation we can obtain is $[1, 2, 3, 4]$ by performing the third operation (swap the third and the fourth elements).
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 100$) — the number of test cases. Then $q$ test cases follow.
The first line of the test case contains one integer $n$ ($1 \le n \le 100$) — the number of elements in the permutation.
The second line of the test case contains $n$ distinct integers from $1$ to $n$ — the given permutation.
-----Output-----
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
-----Example-----
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
-----Note-----
Recall that the permutation $p$ of length $n$ is lexicographically less than the permutation $q$ of length $n$ if there is such index $i \le n$ that for all $j$ from $1$ to $i - 1$ the condition $p_j = q_j$ is satisfied, and $p_i < q_i$. For example:
$p = [1, 3, 5, 2, 4]$ is less than $q = [1, 3, 5, 4, 2]$ (such $i=4$ exists, that $p_i < q_i$ and for each $j < i$ holds $p_j = q_j$), $p = [1, 2]$ is less than $q = [2, 1]$ (such $i=1$ exists, that $p_i < q_i$ and for each $j < i$ holds $p_j = q_j$).
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
q = int(input())
for qi in range(q):
n = int(input())
a = list(map(int, input().split()))
used = [False] * n
for t in range(n):
for i in range(len(a) - 1, 0, -1):
if used[i]:
continue
if a[i] < a[i - 1]:
a[i], a[i - 1] = a[i - 1], a[i]
used[i] = True
print(' '.join(str(x) for x in a))
``` | vfc_27293 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1256/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n5\n5 4 1 3 2\n4\n1 2 4 3\n1\n1\n4\n4 3 2 1\n",
"output": "1 5 2 4 3 \n1 2 3 4 \n1 \n1 4 3 2 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n5\n4 2 3 5 1\n",
"output": "1 4 2 3 5 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4652 | Solve the following coding problem using the programming language python:
There are $n$ students standing in a circle in some order. The index of the $i$-th student is $p_i$. It is guaranteed that all indices of students are distinct integers from $1$ to $n$ (i. e. they form a permutation).
Students want to start a round dance. A clockwise round dance can be started if the student $2$ comes right after the student $1$ in clockwise order (there are no students between them), the student $3$ comes right after the student $2$ in clockwise order, and so on, and the student $n$ comes right after the student $n - 1$ in clockwise order. A counterclockwise round dance is almost the same thing — the only difference is that the student $i$ should be right after the student $i - 1$ in counterclockwise order (this condition should be met for every $i$ from $2$ to $n$).
For example, if the indices of students listed in clockwise order are $[2, 3, 4, 5, 1]$, then they can start a clockwise round dance. If the students have indices $[3, 2, 1, 4]$ in clockwise order, then they can start a counterclockwise round dance.
Your task is to determine whether it is possible to start a round dance. Note that the students cannot change their positions before starting the dance; they cannot swap or leave the circle, and no other student can enter the circle.
You have to answer $q$ independent queries.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 200$) — the number of queries. Then $q$ queries follow.
The first line of the query contains one integer $n$ ($1 \le n \le 200$) — the number of students.
The second line of the query contains a permutation of indices $p_1, p_2, \dots, p_n$ ($1 \le p_i \le n$), where $p_i$ is the index of the $i$-th student (in clockwise order). It is guaranteed that all $p_i$ are distinct integers from $1$ to $n$ (i. e. they form a permutation).
-----Output-----
For each query, print the answer on it. If a round dance can be started with the given order of students, print "YES". Otherwise print "NO".
-----Example-----
Input
5
4
1 2 3 4
3
1 3 2
5
1 2 3 5 4
1
1
5
3 2 1 5 4
Output
YES
YES
NO
YES
YES
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
'''input
5
4
1 2 3 4
3
1 3 2
5
1 2 3 5 4
1
1
5
3 2 1 5 4
'''
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
from heapq import heappush as hpush
from heapq import heappop as hpop
mod=10**9+7
def ri(flag=0):
if flag==0:
return [int(i) for i in sys.stdin.readline().split()]
else:
return int(sys.stdin.readline())
for _ in range(ri(1)):
n = ri(1)
a= ri()
idx = a.index(1)
check1 = 1
check2 =1
for i in range(n):
if a[(idx+i)%n] == i+1:
pass
else:
check1=0
a=a[::-1]
idx = a.index(1)
for i in range(n):
if a[(idx+i)%n] == i+1:
pass
else:
check2=0
if check1==1 or check2==1:
print("YES")
else:
print("NO")
``` | vfc_27297 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1203/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n4\n1 2 3 4\n3\n1 3 2\n5\n1 2 3 5 4\n1\n1\n5\n3 2 1 5 4\n",
"output": "YES\nYES\nNO\nYES\nYES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n12\n12 3 4 5 6 7 8 9 10 11 1 2\n",
"output": "NO\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4653 | Solve the following coding problem using the programming language python:
Santa has $n$ candies and he wants to gift them to $k$ kids. He wants to divide as many candies as possible between all $k$ kids. Santa can't divide one candy into parts but he is allowed to not use some candies at all.
Suppose the kid who recieves the minimum number of candies has $a$ candies and the kid who recieves the maximum number of candies has $b$ candies. Then Santa will be satisfied, if the both conditions are met at the same time:
$b - a \le 1$ (it means $b = a$ or $b = a + 1$); the number of kids who has $a+1$ candies (note that $a+1$ not necessarily equals $b$) does not exceed $\lfloor\frac{k}{2}\rfloor$ (less than or equal to $\lfloor\frac{k}{2}\rfloor$).
$\lfloor\frac{k}{2}\rfloor$ is $k$ divided by $2$ and rounded down to the nearest integer. For example, if $k=5$ then $\lfloor\frac{k}{2}\rfloor=\lfloor\frac{5}{2}\rfloor=2$.
Your task is to find the maximum number of candies Santa can give to kids so that he will be satisfied.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 5 \cdot 10^4$) — the number of test cases.
The next $t$ lines describe test cases. The $i$-th test case contains two integers $n$ and $k$ ($1 \le n, k \le 10^9$) — the number of candies and the number of kids.
-----Output-----
For each test case print the answer on it — the maximum number of candies Santa can give to kids so that he will be satisfied.
-----Example-----
Input
5
5 2
19 4
12 7
6 2
100000 50010
Output
5
18
10
6
75015
-----Note-----
In the first test case, Santa can give $3$ and $2$ candies to kids. There $a=2, b=3,a+1=3$.
In the second test case, Santa can give $5, 5, 4$ and $4$ candies. There $a=4,b=5,a+1=5$. The answer cannot be greater because then the number of kids with $5$ candies will be $3$.
In the third test case, Santa can distribute candies in the following way: $[1, 2, 2, 1, 1, 2, 1]$. There $a=1,b=2,a+1=2$. He cannot distribute two remaining candies in a way to be satisfied.
In the fourth test case, Santa can distribute candies in the following way: $[3, 3]$. There $a=3, b=3, a+1=4$. Santa distributed all $6$ candies.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
q = int(input())
for z in range(q):
n, k = map(int, input().split())
x = n // k
n -= x * k
m = min(k // 2, n)
print(x * k + m)
``` | vfc_27301 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1283/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n5 2\n19 4\n12 7\n6 2\n100000 50010\n",
"output": "5\n18\n10\n6\n75015\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4655 | Solve the following coding problem using the programming language python:
Alice and Bob have received three big piles of candies as a gift. Now they want to divide these candies as fair as possible. To do this, Alice takes one pile of candies, then Bob takes one of the other two piles. The last pile is split between Alice and Bob as they want: for example, it is possible that Alice takes the whole pile, and Bob gets nothing from it.
After taking the candies from the piles, if Alice has more candies than Bob, she discards some candies so that the number of candies she has is equal to the number of candies Bob has. Of course, Bob does the same if he has more candies.
Alice and Bob want to have as many candies as possible, and they plan the process of dividing candies accordingly. Please calculate the maximum number of candies Alice can have after this division process (of course, Bob will have the same number of candies).
You have to answer $q$ independent queries.
Let's see the following example: $[1, 3, 4]$. Then Alice can choose the third pile, Bob can take the second pile, and then the only candy from the first pile goes to Bob — then Alice has $4$ candies, and Bob has $4$ candies.
Another example is $[1, 10, 100]$. Then Alice can choose the second pile, Bob can choose the first pile, and candies from the third pile can be divided in such a way that Bob takes $54$ candies, and Alice takes $46$ candies. Now Bob has $55$ candies, and Alice has $56$ candies, so she has to discard one candy — and after that, she has $55$ candies too.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 1000$) — the number of queries. Then $q$ queries follow.
The only line of the query contains three integers $a, b$ and $c$ ($1 \le a, b, c \le 10^{16}$) — the number of candies in the first, second and third piles correspondingly.
-----Output-----
Print $q$ lines. The $i$-th line should contain the answer for the $i$-th query — the maximum number of candies Alice can have after the division, if both Alice and Bob act optimally (of course, Bob will have the same number of candies).
-----Example-----
Input
4
1 3 4
1 10 100
10000000000000000 10000000000000000 10000000000000000
23 34 45
Output
4
55
15000000000000000
51
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from sys import stdin,stdout
import sys
import math
t=int(stdin.readline())
for i in range(t):
a=list(map(int,stdin.readline().split()))
print(sum(a)//2)
``` | vfc_27309 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1196/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n1 3 4\n1 10 100\n10000000000000000 10000000000000000 10000000000000000\n23 34 45\n",
"output": "4\n55\n15000000000000000\n51\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n111 2 3\n",
"output": "58\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4656 | Solve the following coding problem using the programming language python:
The store sells $n$ beads. The color of each bead is described by a lowercase letter of the English alphabet ("a"–"z"). You want to buy some beads to assemble a necklace from them.
A necklace is a set of beads connected in a circle.
For example, if the store sells beads "a", "b", "c", "a", "c", "c", then you can assemble the following necklaces (these are not all possible options): [Image]
And the following necklaces cannot be assembled from beads sold in the store: [Image] The first necklace cannot be assembled because it has three beads "a" (of the two available). The second necklace cannot be assembled because it contains a bead "d", which is not sold in the store.
We call a necklace $k$-beautiful if, when it is turned clockwise by $k$ beads, the necklace remains unchanged. For example, here is a sequence of three turns of a necklace. [Image] As you can see, this necklace is, for example, $3$-beautiful, $6$-beautiful, $9$-beautiful, and so on, but it is not $1$-beautiful or $2$-beautiful.
In particular, a necklace of length $1$ is $k$-beautiful for any integer $k$. A necklace that consists of beads of the same color is also beautiful for any $k$.
You are given the integers $n$ and $k$, and also the string $s$ containing $n$ lowercase letters of the English alphabet — each letter defines a bead in the store. You can buy any subset of beads and connect them in any order. Find the maximum length of a $k$-beautiful necklace you can assemble.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 100$) — the number of test cases in the test. Then $t$ test cases follow.
The first line of each test case contains two integers $n$ and $k$ ($1 \le n, k \le 2000$).
The second line of each test case contains the string $s$ containing $n$ lowercase English letters — the beads in the store.
It is guaranteed that the sum of $n$ for all test cases does not exceed $2000$.
-----Output-----
Output $t$ answers to the test cases. Each answer is a positive integer — the maximum length of the $k$-beautiful necklace you can assemble.
-----Example-----
Input
6
6 3
abcbac
3 6
aaa
7 1000
abczgyo
5 4
ababa
20 10
aaebdbabdbbddaadaadc
20 5
ecbedececacbcbccbdec
Output
6
3
5
4
15
10
-----Note-----
The first test case is explained in the statement.
In the second test case, a $6$-beautiful necklace can be assembled from all the letters.
In the third test case, a $1000$-beautiful necklace can be assembled, for example, from beads "abzyo".
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t = int(input())
def gcd(a,b):
if b == 0:
return a
return gcd(b,a%b)
for _ in range(t):
n,k = map(int,input().split())
s = input()
occ = [0] * 26
for i in s:
occ[ord(i)-97] += 1
occ.sort()
occ.reverse()
for l in range(1,n+1):
cycle = gcd(l,k)
need = l//cycle
su = 0
for i in occ:
su += i//need
if su*need >= l:
wyn = l
print(wyn)
``` | vfc_27313 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1367/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6\n6 3\nabcbac\n3 6\naaa\n7 1000\nabczgyo\n5 4\nababa\n20 10\naaebdbabdbbddaadaadc\n20 5\necbedececacbcbccbdec\n",
"output": "6\n3\n5\n4\n15\n10\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n7 1782\nabcabca\n",
"output": "6\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4657 | Solve the following coding problem using the programming language python:
You are given an array $a$ consisting of $n$ integers $a_1, a_2, \dots, a_n$. You want to split it into exactly $k$ non-empty non-intersecting subsegments such that each subsegment has odd sum (i. e. for each subsegment, the sum of all elements that belong to this subsegment is odd). It is impossible to rearrange (shuffle) the elements of a given array. Each of the $n$ elements of the array $a$ must belong to exactly one of the $k$ subsegments.
Let's see some examples of dividing the array of length $5$ into $3$ subsegments (not necessarily with odd sums): $[1, 2, 3, 4, 5]$ is the initial array, then all possible ways to divide it into $3$ non-empty non-intersecting subsegments are described below: $[1], [2], [3, 4, 5]$; $[1], [2, 3], [4, 5]$; $[1], [2, 3, 4], [5]$; $[1, 2], [3], [4, 5]$; $[1, 2], [3, 4], [5]$; $[1, 2, 3], [4], [5]$.
Of course, it can be impossible to divide the initial array into exactly $k$ subsegments in such a way that each of them will have odd sum of elements. In this case print "NO". Otherwise, print "YES" and any possible division of the array. See the output format for the detailed explanation.
You have to answer $q$ independent queries.
-----Input-----
The first line contains one integer $q$ ($1 \le q \le 2 \cdot 10^5$) — the number of queries. Then $q$ queries follow.
The first line of the query contains two integers $n$ and $k$ ($1 \le k \le n \le 2 \cdot 10^5$) — the number of elements in the array and the number of subsegments, respectively.
The second line of the query contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^9$), where $a_i$ is the $i$-th element of $a$.
It is guaranteed that the sum of $n$ over all queries does not exceed $2 \cdot 10^5$ ($\sum n \le 2 \cdot 10^5$).
-----Output-----
For each query, print the answer to it. If it is impossible to divide the initial array into exactly $k$ subsegments in such a way that each of them will have odd sum of elements, print "NO" in the first line. Otherwise, print "YES" in the first line and any possible division of the array in the second line. The division can be represented as $k$ integers $r_1$, $r_2$, ..., $r_k$ such that $1 \le r_1 < r_2 < \dots < r_k = n$, where $r_j$ is the right border of the $j$-th segment (the index of the last element that belongs to the $j$-th segment), so the array is divided into subsegments $[1; r_1], [r_1 + 1; r_2], [r_2 + 1, r_3], \dots, [r_{k - 1} + 1, n]$. Note that $r_k$ is always $n$ but you should print it anyway.
-----Example-----
Input
3
5 3
7 18 3 14 1
5 4
1 2 3 4 5
6 2
1 2 8 4 10 2
Output
YES
1 3 5
NO
NO
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from sys import stdin
c=int(stdin.readline().strip())
for cas in range(c):
n,m=list(map(int,stdin.readline().strip().split()))
s=list(map(int,stdin.readline().strip().split()))
sm=0
ans=[]
ind=-1
for i in range(n):
if m==1:
ind=i
break
sm+=s[i]
if sm%2!=0:
ans.append(i+1)
sm=0
m-=1
if ind==-1:
print("NO")
continue
sm=sum(s[ind::])
if sm%2!=0:
ans.append(n)
print("YES")
print(*ans)
else:
print("NO")
``` | vfc_27317 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1196/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n5 3\n7 18 3 14 1\n5 4\n1 2 3 4 5\n6 2\n1 2 8 4 10 2\n",
"output": "YES\n1 3 5\nNO\nNO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1 1\n2\n",
"output": "NO\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4750 | Solve the following coding problem using the programming language python:
You are given two segments $[l_1; r_1]$ and $[l_2; r_2]$ on the $x$-axis. It is guaranteed that $l_1 < r_1$ and $l_2 < r_2$. Segments may intersect, overlap or even coincide with each other. [Image] The example of two segments on the $x$-axis.
Your problem is to find two integers $a$ and $b$ such that $l_1 \le a \le r_1$, $l_2 \le b \le r_2$ and $a \ne b$. In other words, you have to choose two distinct integer points in such a way that the first point belongs to the segment $[l_1; r_1]$ and the second one belongs to the segment $[l_2; r_2]$.
It is guaranteed that the answer exists. If there are multiple answers, you can print any of them.
You have to answer $q$ independent queries.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 500$) — the number of queries.
Each of the next $q$ lines contains four integers $l_{1_i}, r_{1_i}, l_{2_i}$ and $r_{2_i}$ ($1 \le l_{1_i}, r_{1_i}, l_{2_i}, r_{2_i} \le 10^9, l_{1_i} < r_{1_i}, l_{2_i} < r_{2_i}$) — the ends of the segments in the $i$-th query.
-----Output-----
Print $2q$ integers. For the $i$-th query print two integers $a_i$ and $b_i$ — such numbers that $l_{1_i} \le a_i \le r_{1_i}$, $l_{2_i} \le b_i \le r_{2_i}$ and $a_i \ne b_i$. Queries are numbered in order of the input.
It is guaranteed that the answer exists. If there are multiple answers, you can print any.
-----Example-----
Input
5
1 2 1 2
2 6 3 4
2 4 1 3
1 2 1 3
1 4 5 8
Output
2 1
3 4
3 2
1 2
3 7
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# !/usr/bin/env python3
# coding: UTF-8
# Modified: <23/Jan/2019 08:06:42 PM>
# ✪ H4WK3yE乡
# Mohd. Farhan Tahir
# Indian Institute Of Information Technology (IIIT),Gwalior
# Question Link
#
#
# ///==========Libraries, Constants and Functions=============///
import sys
inf = float("inf")
mod = 1000000007
def get_array(): return list(map(int, sys.stdin.readline().split()))
def get_ints(): return list(map(int, sys.stdin.readline().split()))
def input(): return sys.stdin.readline()
# ///==========MAIN=============///
def main():
for tc in range(int(input())):
l1, r1, l2, r2 = get_ints()
if l1 != l2:
print(l1, l2)
else:
print(l1, r2)
def __starting_point():
main()
__starting_point()
``` | vfc_27610 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1108/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n1 2 1 2\n2 6 3 4\n2 4 1 3\n1 2 1 3\n1 4 5 8\n",
"output": "2 1\n4 3\n3 1\n1 3\n4 8\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1 2 1 2\n",
"output": "2 1\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | brcktsrm | Solve the following coding problem using the programming language python:
Problem description.
Vipul is a hardworking super-hero who maintains the bracket ratio of all the strings in the world. Recently he indulged himself in saving the string population so much that he lost his ability for checking brackets (luckily, not permanently ).Being his super-hero friend help him in his time of hardship.
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test case contains a single string S denoting the string to be checked.
Output
For each test case, output a single line printing "YES" or "NO" (without " " and in uppercase only) , denoting if the brackets in the given string is balanced or not .
Constraints
1 ≤ T ≤ 10
1 ≤ length of S ≤ 60
Example
Input:
3
((()))
(())()
()(()
Output:
YES
YES
NO
Explanation
Example is self-explanatory.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
for _ in range(input()):
try:
eval(raw_input())
print 'YES'
except TypeError:
print 'YES'
except:
print 'NO'
``` | vfc_28357 | {
"difficulty": "6",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n((()))\n(())()\n()(()",
"output": "YES\nYES\nNO",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n((()))\n(())()\n()())",
"output": "YES\nYES\nNO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n((()()\n(())()\n()(()",
"output": "NO\nYES\nNO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n((()))\n(())))\n()())",
"output": "YES\nNO\nNO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n)))(((\n(())))\n()())",
"output": "NO\nNO\nNO\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | comm3 | Solve the following coding problem using the programming language python:
The Chef likes to stay in touch with his staff. So, the Chef, the head server, and the sous-chef all carry two-way transceivers so they can stay in constant contact. Of course, these transceivers have a limited range so if two are too far apart, they cannot communicate directly.
The Chef invested in top-of-the-line transceivers which have a few advanced features. One is that even if two people cannot talk directly because they are out of range, if there is another transceiver that is close enough to both, then the two transceivers can still communicate with each other using the third transceiver as an intermediate device.
There has been a minor emergency in the Chef's restaurant
and he needs to communicate with both the head server and the sous-chef right away. Help the Chef determine if it is possible for all three people to communicate with each other, even if two must communicate through the third because they are too far apart.
Input
The first line contains a single positive integer T ≤ 100 indicating the number of test cases to follow. The first line of each test case contains a positive integer R ≤ 1,000 indicating that two transceivers can communicate directly without an intermediate transceiver if they are at most R meters away from each other. The remaining three lines of the test case describe the current locations of the Chef, the head server, and the sous-chef, respectively. Each such line contains two integers X,Y (at most 10,000 in absolute value) indicating that the respective person is located at position X,Y.
Output
For each test case you are to output a single line containing a single string. If it is possible for all three to communicate then you should output "yes". Otherwise, you should output "no".
To be clear, we say that two transceivers are close enough to communicate directly if the length of the straight line connecting their X,Y coordinates is at most R.
Example
Input:
3
1
0 1
0 0
1 0
2
0 1
0 0
1 0
2
0 0
0 2
2 1
Output:
yes
yes
no
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import math
no_of_testcases = int(input())
for each in range(no_of_testcases):
dist = int(input())
point_1 = map(int,raw_input().split())
point_2 = map(int,raw_input().split())
point_3 = map(int,raw_input().split())
point_12 =math.sqrt( math.pow((point_1[0] -point_2[0]),2) + math.pow((point_1[1] -point_2[1]),2))
point_23 =math.sqrt( math.pow((point_2[0] -point_3[0]),2) + math.pow((point_2[1] -point_3[1]),2))
point_31 =math.sqrt( math.pow((point_3[0] -point_1[0]),2) + math.pow((point_3[1] -point_1[1]),2))
count =0
if point_12 <= dist:
count =count+1
if point_23 <= dist:
count =count+1
if point_31 <= dist:
count =count+1
if count >=2:
print "yes"
else:
print "no"
``` | vfc_28361 | {
"difficulty": "1",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n1\n0 1\n0 0\n1 0\n2\n0 1\n0 0\n1 0\n2\n0 0\n0 2\n2 1",
"output": "yes\nyes\nno\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n1\n0 1\n0 -1\n1 0\n2\n0 1\n0 0\n1 0\n2\n0 0\n0 2\n2 1",
"output": "no\nyes\nno\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n2\n0 1\n0 -1\n1 0\n2\n0 1\n0 0\n1 0\n2\n0 0\n0 2\n2 1",
"output": "yes\nyes\nno\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n2\n0 -1\n0 -1\n1 0\n2\n0 0\n0 0\n1 0\n2\n1 0\n1 2\n2 1",
"output": "yes\nyes\nyes\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | gcd2 | Solve the following coding problem using the programming language python:
Frank explained its friend Felman the algorithm of Euclides to calculate the GCD
of two numbers. Then Felman implements it algorithm
int gcd(int a, int b)
{
if (b==0)
return a;
else
return gcd(b,a%b);
}
and it proposes to Frank that makes it
but with a little integer and another integer that has up to 250 digits.
Your task is to help Frank programming an efficient code for the challenge of Felman.
Input
The first line of the input file contains a number representing the number of lines to follow.
Each line consists of two number A and B (0 ≤ A ≤ 40000 and A ≤ B < 10^250).
Output
Print for each pair (A,B) in the input one integer representing the GCD of A and B.
Example
Input:
2
2 6
10 11
Output:
2
1
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
def gcd(a,b):
while(b):
a,b=b,a%b
return a
t=input()
while(t):
a,b=map(int,raw_input().split())
print(gcd(a,b))
t=t-1;
``` | vfc_28365 | {
"difficulty": "2",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n2 6\n10 11",
"output": "2\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n3 6\n10 11",
"output": "3\n1\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | luckybal | Solve the following coding problem using the programming language python:
A Little Elephant from the Zoo of Lviv likes lucky strings, i.e., the strings that consist only of the lucky digits 4 and 7.
The Little Elephant calls some string T of the length M balanced if there exists at least one integer X (1 ≤ X ≤ M) such that the number of digits 4 in the substring T[1, X - 1] is equal to the number of digits 7 in the substring T[X, M]. For example, the string S = 7477447 is balanced since S[1, 4] = 7477 has 1 digit 4 and S[5, 7] = 447 has 1 digit 7. On the other hand, one can verify that the string S = 7 is not balanced.
The Little Elephant has the string S of the length N. He wants to know the number of such pairs of integers (L; R) that 1 ≤ L ≤ R ≤ N and the substring S[L, R] is balanced. Help him to find this number.
Notes.
Let S be some lucky string. Then
|S| denotes the length of the string S;
S[i] (1 ≤ i ≤ |S|) denotes the i^th character of S (the numeration of characters starts from 1);
S[L, R] (1 ≤ L ≤ R ≤ |S|) denotes the string with the following sequence of characters: S[L], S[L + 1], ..., S[R], and is called a substring of S. For L > R we mean by S[L, R] an empty string.
Input
The first line of the input file contains a single integer T, the number of test cases. Each of the following T lines contains one string, the string S for the corresponding test case. The input file does not contain any whitespaces.
Output
For each test case output a single line containing the answer for this test case.
Constraints
1 ≤ T ≤ 10
1 ≤ |S| ≤ 100000
S consists only of the lucky digits 4 and 7.
Example
Input:
4
47
74
477
4747477
Output:
2
2
3
23
Explanation
In the first test case balance substrings are S[1, 1] = 4 and S[1, 2] = 47.
In the second test case balance substrings are S[2, 2] = 4 and S[1, 2] = 74.
Unfortunately, we can't provide you with the explanations of the third and the fourth test cases. You should figure it out by yourself. Please, don't ask about this in comments.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
n = input()
for i in range(n):
str = raw_input()
l = len(str)
megacounter = 0
counter = 0
i = 0
while(1):
while(i<l and str[i]=='7'):
i=i+1
counter=counter+1
if(i>=l):
break
megacounter = megacounter + (counter*(counter+1))/2
i=i+1
counter=0
megacounter = megacounter + (counter*(counter+1))/2
supercounter = (l*(l+1))/2 - megacounter
print supercounter
``` | vfc_28369 | {
"difficulty": "2",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n47\n74\n477\n4747477",
"output": "2\n2\n3\n23\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n47\n47\n477\n4747477",
"output": "2\n2\n3\n23\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n7\n47\n477\n4747477",
"output": "0\n2\n3\n23\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n4\n47\n477\n4747477",
"output": "1\n2\n3\n23\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | prpaln | Solve the following coding problem using the programming language python:
Given a string s. Can you make it a palindrome by deleting exactly one character? Note that size of the string after deletion would be one less than it was before.
Input
First line of the input contains a single integer T denoting number of test cases.
For each test case, you are given a single line containing string s.
Output
For each test case, print YES or NO depending on the answer of the problem.
Constraints
Example
Input:
4
aaa
abc
abdbca
abba
Output:
YES
NO
YES
YES
Explanation
Example case 1. Delete any one 'a', resulting string is "aa" which is a palindrome.
Example case 2. It is not possible to delete exactly one character and having a palindrome.
Example case 3. Delete 'c', resulting string is "abdba" which is a palindrome.
Example case 4. Delete 'b', resulting string is "aba" which is a palindrome.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import math
import sys
def checkpal(s):
return s==s[::-1]
for a in range(input()):
s=raw_input()
l=len(s)
if(l==2):
print "YES"
else:
if checkpal(s):
print "YES"
else:
while s[0] == s[-1] and len(s)>2:
s=s[1:-1]
if checkpal(s[1:]) or checkpal(s[:-1]):
print "YES"
else:
print "NO"
``` | vfc_28373 | {
"difficulty": "2",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\naaa\nabc\nabdbca\nabba",
"output": "YES\nNO\nYES\nYES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\naaa\nabc\nabdbca\nabca",
"output": "YES\nNO\nYES\nYES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\naaa\nabc\nabdbc`\naaca",
"output": "YES\nNO\nNO\nYES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\naab\nacc\n`bd`cb\naaad",
"output": "YES\nYES\nNO\nYES\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | tf01 | Solve the following coding problem using the programming language python:
An established group of scientists are working on finding solution to NP hard problems. They claim Subset Sum as an NP-hard problem. The problem is to determine whether there exists a subset of a given set S whose sum is a given number K.
You are a computer engineer and you claim to solve this problem given that all numbers in the set are non-negative. Given a set S of size N of non-negative integers, find whether there exists a subset whose sum is K.
Input
First line of input contains T, the number of test cases. T test cases follow.
Each test case contains 2 lines. First line contains two integers N and K. Next line contains N space separated non-negative integers (each less than 100000).
0 < T < 1000
0 < N < 1000
0 < K < 1000
Output
Output T lines, one for each test case. Every line should be either 0 or 1 depending on whether such a subset exists or not.
Example
Input:
2
5 10
3 4 6 1 9
3 2
1 3 4
Output:
1
0
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import sys
for __ in range(input()) :
n , k = map(int,sys.stdin.readline().split())
lists = map(int,sys.stdin.readline().split())
dp = [0]*(k+1)
dp[0]=1
for i in lists :
for j in range(k-i,-1,-1) :
if dp[k] :
break
if dp[j] :
dp[j+i] = 1
print dp[k]
``` | vfc_28377 | {
"difficulty": "6",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n5 10\n3 4 6 1 9\n3 2\n1 3 4",
"output": "1\n0",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1037_E. Trips | Solve the following coding problem using the programming language python:
There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
from collections import deque
def solve(adj, m, k, uv):
n = len(adj)
nn = [len(a) for a in adj]
q = deque()
for i in range(n):
if nn[i] < k:
q.append(i)
while q:
v = q.popleft()
for u in adj[v]:
nn[u] -= 1
if nn[u] == k-1:
q.append(u)
res = [0]*m
nk = len([1 for i in nn if i >= k])
res[-1] = nk
for i in range(m-1, 0, -1):
u1, v1 = uv[i]
if nn[u1] < k or nn[v1] < k:
res[i - 1] = nk
continue
if nn[u1] == k:
q.append(u1)
nn[u1] -= 1
if not q and nn[v1] == k:
q.append(v1)
nn[v1] -= 1
if not q:
nn[u1] -= 1
nn[v1] -= 1
adj[u1].remove(v1)
adj[v1].remove(u1)
while q:
v = q.popleft()
nk -= 1
for u in adj[v]:
nn[u] -= 1
if nn[u] == k - 1:
q.append(u)
res[i - 1] = nk
return res
n, m, k = map(int, input().split())
a = [set() for i in range(n)]
uv = []
for i in range(m):
u, v = map(int, input().split())
a[u - 1].add(v - 1)
a[v - 1].add(u - 1)
uv.append((u-1, v-1))
res = solve(a, m, k, uv)
print(str(res)[1:-1].replace(' ', '').replace(',', '\n'))
``` | vfc_28385 | {
"difficulty": "11",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"output": "0\n0\n3\n3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"output": "0\n0\n0\n3\n3\n4\n4\n5\n",
"type": "stdin_stdout"
}
]
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.