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 | 3958 | Solve the following coding problem using the programming language python:
Oleg writes down the history of the days he lived. For each day he decides if it was good or bad. Oleg calls a non-empty sequence of days a zebra, if it starts with a bad day, ends with a bad day, and good and bad days are alternating in it. Let us denote bad days as 0 and good days as 1. Then, for example, sequences of days 0, 010, 01010 are zebras, while sequences 1, 0110, 0101 are not.
Oleg tells you the story of days he lived in chronological order in form of string consisting of 0 and 1. Now you are interested if it is possible to divide Oleg's life history into several subsequences, each of which is a zebra, and the way it can be done. Each day must belong to exactly one of the subsequences. For each of the subsequences, days forming it must be ordered chronologically. Note that subsequence does not have to be a group of consecutive days.
-----Input-----
In the only line of input data there is a non-empty string s consisting of characters 0 and 1, which describes the history of Oleg's life. Its length (denoted as |s|) does not exceed 200 000 characters.
-----Output-----
If there is a way to divide history into zebra subsequences, in the first line of output you should print an integer k (1 ≤ k ≤ |s|), the resulting number of subsequences. In the i-th of following k lines first print the integer l_{i} (1 ≤ l_{i} ≤ |s|), which is the length of the i-th subsequence, and then l_{i} indices of days forming the subsequence. Indices must follow in ascending order. Days are numbered starting from 1. Each index from 1 to n must belong to exactly one subsequence. If there is no way to divide day history into zebra subsequences, print -1.
Subsequences may be printed in any order. If there are several solutions, you may print any of them. You do not have to minimize nor maximize the value of k.
-----Examples-----
Input
0010100
Output
3
3 1 3 4
3 2 5 6
1 7
Input
111
Output
-1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
s = input()
zero = set() # 前面的一个以0结尾的串的索引
one = set() # 前面的一个以1结尾的串的索引
ans = [] # 结果的串
for i in range(0,len(s)):
if(s[i] == '0'):
if one:
k = one.pop()
zero.add(k)
ans[k].append(i+1)
else:
zero.add(len(ans))
ans.append([i+1])
else:
if not zero:
print(-1)
return
k = zero.pop()
one.add(k)
ans[k].append(i+1)
if(one):
print(-1)
return
print(len(ans))
print('\n'.join([str(len(x))+' '+' '.join(map(str,x)) for x in ans]))
``` | vfc_24539 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/949/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "0010100\n",
"output": "3\n1 1\n5 2 3 4 5 6\n1 7\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "111\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "0\n",
"output": "1\n1 1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "0101010101\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "010100001\n",
"output": "-1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3959 | Solve the following coding problem using the programming language python:
It's that time of the year, Felicity is around the corner and you can see people celebrating all around the Himalayan region. The Himalayan region has n gyms. The i-th gym has g_{i} Pokemon in it. There are m distinct Pokemon types in the Himalayan region numbered from 1 to m. There is a special evolution camp set up in the fest which claims to evolve any Pokemon. The type of a Pokemon could change after evolving, subject to the constraint that if two Pokemon have the same type before evolving, they will have the same type after evolving. Also, if two Pokemon have different types before evolving, they will have different types after evolving. It is also possible that a Pokemon has the same type before and after evolving.
Formally, an evolution plan is a permutation f of {1, 2, ..., m}, such that f(x) = y means that a Pokemon of type x evolves into a Pokemon of type y.
The gym leaders are intrigued by the special evolution camp and all of them plan to evolve their Pokemons. The protocol of the mountain states that in each gym, for every type of Pokemon, the number of Pokemon of that type before evolving any Pokemon should be equal the number of Pokemon of that type after evolving all the Pokemons according to the evolution plan. They now want to find out how many distinct evolution plans exist which satisfy the protocol.
Two evolution plans f_1 and f_2 are distinct, if they have at least one Pokemon type evolving into a different Pokemon type in the two plans, i. e. there exists an i such that f_1(i) ≠ f_2(i).
Your task is to find how many distinct evolution plans are possible such that if all Pokemon in all the gyms are evolved, the number of Pokemon of each type in each of the gyms remains the same. As the answer can be large, output it modulo 10^9 + 7.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^6) — the number of gyms and the number of Pokemon types.
The next n lines contain the description of Pokemons in the gyms. The i-th of these lines begins with the integer g_{i} (1 ≤ g_{i} ≤ 10^5) — the number of Pokemon in the i-th gym. After that g_{i} integers follow, denoting types of the Pokemons in the i-th gym. Each of these integers is between 1 and m.
The total number of Pokemons (the sum of all g_{i}) does not exceed 5·10^5.
-----Output-----
Output the number of valid evolution plans modulo 10^9 + 7.
-----Examples-----
Input
2 3
2 1 2
2 2 3
Output
1
Input
1 3
3 1 2 3
Output
6
Input
2 4
2 1 2
3 2 3 4
Output
2
Input
2 2
3 2 2 1
2 1 2
Output
1
Input
3 7
2 1 2
2 3 4
3 5 6 7
Output
24
-----Note-----
In the first case, the only possible evolution plan is: $1 \rightarrow 1,2 \rightarrow 2,3 \rightarrow 3$
In the second case, any permutation of (1, 2, 3) is valid.
In the third case, there are two possible plans: $1 \rightarrow 1,2 \rightarrow 2,3 \rightarrow 4,4 \rightarrow 3$ $1 \rightarrow 1,2 \rightarrow 2,3 \rightarrow 3,4 \rightarrow 4$
In the fourth case, the only possible evolution plan is: $1 \rightarrow 1,2 \rightarrow 2$
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 defaultdict, Counter
P = 10 ** 9 + 7
def factmod(n):
res = 1
for i in range(2, n+1):
res *= i
res %= P
return res
def solve():
n, m = list(map(int, input().split()))
colour = {i:0 for i in range(1, m+1)}
colour_map = {}
for i, line in enumerate(sys.stdin):
A = [int(x) for x in line.split()]
count = Counter(A)
if count[A[0]] == 1:
count.pop(A[0])
else:
count[A[0]] -= 1
for c in count:
p = (colour[c], i, count[c])
if p in colour_map:
colour[c] = colour_map[p]
else:
colour[c] = colour_map[p] = len(colour_map) + 1
count = Counter(list(colour.values()))
res = 1
for c in count:
res *= factmod(count[c])
res %= P
return res
print(solve())
``` | vfc_24543 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/757/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2 3\n2 1 2\n2 2 3\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 3\n3 1 2 3\n",
"output": "6\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3960 | Solve the following coding problem using the programming language python:
Something happened in Uzhlyandia again... There are riots on the streets... Famous Uzhlyandian superheroes Shean the Sheep and Stas the Giraffe were called in order to save the situation. Upon the arriving, they found that citizens are worried about maximum values of the Main Uzhlyandian Function f, which is defined as follows:$f(l, r) = \sum_{i = l}^{r - 1}|a [ i ] - a [ i + 1 ]|\cdot(- 1)^{i - l}$
In the above formula, 1 ≤ l < r ≤ n must hold, where n is the size of the Main Uzhlyandian Array a, and |x| means absolute value of x. But the heroes skipped their math lessons in school, so they asked you for help. Help them calculate the maximum value of f among all possible values of l and r for the given array a.
-----Input-----
The first line contains single integer n (2 ≤ n ≤ 10^5) — the size of the array a.
The second line contains n integers a_1, a_2, ..., a_{n} (-10^9 ≤ a_{i} ≤ 10^9) — the array elements.
-----Output-----
Print the only integer — the maximum value of f.
-----Examples-----
Input
5
1 4 2 3 1
Output
3
Input
4
1 5 4 7
Output
6
-----Note-----
In the first sample case, the optimal value of f is reached on intervals [1, 2] and [2, 5].
In the second case maximal value of f is reachable only on the whole array.
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())
l = tuple(map(int, input().split()))
a = []
for i in range(n - 1):
a.append(abs(l[i] - l[i + 1]))
ev = [(a[i] if i % 2 == 0 else -a[i]) for i in range(n - 1)]
od = [-i for i in ev]
od[0] = 0
dp = [ev[0]]
st = ["ev"]
# print(a)
# print(ev)
# print(od)
vmax = dp[0]
evsum = evans = 0
odsum = odans = 0
for i in range(0, n - 1):
evsum += ev[i]
odsum += od[i]
evans = max(evsum, evans)
odans = max(odsum, odans)
if evsum < 0 and i % 2 == 1:
evsum = 0
if odsum < 0 and i % 2 == 0:
odsum = 0
# print(evans, odans)
print(max(evans, odans))
``` | vfc_24547 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/788/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n1 4 2 3 1\n",
"output": "3",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n1 5 4 7\n",
"output": "6",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3961 | Solve the following coding problem using the programming language python:
One day, little Vasya found himself in a maze consisting of (n + 1) rooms, numbered from 1 to (n + 1). Initially, Vasya is at the first room and to get out of the maze, he needs to get to the (n + 1)-th one.
The maze is organized as follows. Each room of the maze has two one-way portals. Let's consider room number i (1 ≤ i ≤ n), someone can use the first portal to move from it to room number (i + 1), also someone can use the second portal to move from it to room number p_{i}, where 1 ≤ p_{i} ≤ i.
In order not to get lost, Vasya decided to act as follows. Each time Vasya enters some room, he paints a cross on its ceiling. Initially, Vasya paints a cross at the ceiling of room 1. Let's assume that Vasya is in room i and has already painted a cross on its ceiling. Then, if the ceiling now contains an odd number of crosses, Vasya uses the second portal (it leads to room p_{i}), otherwise Vasya uses the first portal.
Help Vasya determine the number of times he needs to use portals to get to room (n + 1) in the end.
-----Input-----
The first line contains integer n (1 ≤ n ≤ 10^3) — the number of rooms. The second line contains n integers p_{i} (1 ≤ p_{i} ≤ i). Each p_{i} denotes the number of the room, that someone can reach, if he will use the second portal in the i-th room.
-----Output-----
Print a single number — the number of portal moves the boy needs to go out of the maze. As the number can be rather large, print it modulo 1000000007 (10^9 + 7).
-----Examples-----
Input
2
1 2
Output
4
Input
4
1 1 2 3
Output
20
Input
5
1 1 1 1 1
Output
62
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n,a= int(input()),list(map(int,input().split()))
f,m= [0]*(n+1),10**9+7
for i in range(n):
if a[i]==i+1:
f[i+1]=f[i]+2
else:
f[i+1]=(2+f[i]*2-f[a[i]-1])%m
print(f[n]%m)
``` | vfc_24551 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/407/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n1 2\n",
"output": "4\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3962 | Solve the following coding problem using the programming language python:
You invited $n$ guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the $i$-th guest wants to have a least $l_i$ free chairs to the left of his chair, and at least $r_i$ free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the $l_i$ chairs to his left and $r_i$ chairs to his right may overlap.
What is smallest total number of chairs you have to use?
-----Input-----
First line contains one integer $n$ — number of guests, ($1 \leqslant n \leqslant 10^5$).
Next $n$ lines contain $n$ pairs of space-separated integers $l_i$ and $r_i$ ($0 \leqslant l_i, r_i \leqslant 10^9$).
-----Output-----
Output a single integer — the smallest number of chairs you have to use.
-----Examples-----
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
-----Note-----
In the second sample the only optimal answer is to use two circles: a circle with $5$ chairs accomodating guests $1$ and $2$, and another one with $10$ chairs accomodationg guests $3$ and $4$.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=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
input = sys.stdin.readline
n=int(input())
lr=[list(map(int,input().split())) for i in range(n)]
L=[lr[i][0] for i in range(n)]
R=[lr[i][1] for i in range(n)]
L.sort()
R.sort()
ANS=0
for i in range(n):
ANS+=max(L[i],R[i])
print(ANS+n)
``` | vfc_24555 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1060/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n1 1\n1 1\n1 1\n",
"output": "6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n1 2\n2 1\n3 5\n5 3\n",
"output": "15\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n5 6\n",
"output": "7\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3963 | Solve the following coding problem using the programming language python:
There are n types of coins in Byteland. Conveniently, the denomination of the coin type k divides the denomination of the coin type k + 1, the denomination of the coin type 1 equals 1 tugrick. The ratio of the denominations of coin types k + 1 and k equals a_{k}. It is known that for each x there are at most 20 coin types of denomination x.
Byteasar has b_{k} coins of type k with him, and he needs to pay exactly m tugricks. It is known that Byteasar never has more than 3·10^5 coins with him. Byteasar want to know how many ways there are to pay exactly m tugricks. Two ways are different if there is an integer k such that the amount of coins of type k differs in these two ways. As all Byteland citizens, Byteasar wants to know the number of ways modulo 10^9 + 7.
-----Input-----
The first line contains single integer n (1 ≤ n ≤ 3·10^5) — the number of coin types.
The second line contains n - 1 integers a_1, a_2, ..., a_{n} - 1 (1 ≤ a_{k} ≤ 10^9) — the ratios between the coin types denominations. It is guaranteed that for each x there are at most 20 coin types of denomination x.
The third line contains n non-negative integers b_1, b_2, ..., b_{n} — the number of coins of each type Byteasar has. It is guaranteed that the sum of these integers doesn't exceed 3·10^5.
The fourth line contains single integer m (0 ≤ m < 10^10000) — the amount in tugricks Byteasar needs to pay.
-----Output-----
Print single integer — the number of ways to pay exactly m tugricks modulo 10^9 + 7.
-----Examples-----
Input
1
4
2
Output
1
Input
2
1
4 4
2
Output
3
Input
3
3 3
10 10 10
17
Output
6
-----Note-----
In the first example Byteasar has 4 coins of denomination 1, and he has to pay 2 tugricks. There is only one way.
In the second example Byteasar has 4 coins of each of two different types of denomination 1, he has to pay 2 tugricks. There are 3 ways: pay one coin of the first type and one coin of the other, pay two coins of the first type, and pay two coins of the second type.
In the third example the denominations are equal to 1, 3, 9.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
p = 1000000007
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
m = int(input())
d = [1] * 300001
td = [0] * 300001
L = b[0]
for i in range(1, n):
if a[i - 1] != 1:
t = m % a[i - 1]
if L < t:
print(0)
return
m //= a[i - 1]
for j in range((L - t) // a[i - 1] + 1):
d[j] = d[t]
t += a[i - 1]
L = j
k = 0
for j in range(L + b[i] + 1):
if j <= L:
k += d[j]
k %= p
td[j] = k
if j >= b[i]:
k -= d[j - b[i]]
L += b[i]
for j in range(L + 1):
d[j] = td[j]
print(d[m] if m <= L else 0)
``` | vfc_24559 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/759/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "1\n\n4\n2\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1\n4 4\n2\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n3 3\n10 10 10\n17\n",
"output": "6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n2\n200000 100000\n34567\n",
"output": "17284\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3964 | Solve the following coding problem using the programming language python:
Programmers working on a large project have just received a task to write exactly m lines of code. There are n programmers working on a project, the i-th of them makes exactly a_{i} bugs in every line of code that he writes.
Let's call a sequence of non-negative integers v_1, v_2, ..., v_{n} a plan, if v_1 + v_2 + ... + v_{n} = m. The programmers follow the plan like that: in the beginning the first programmer writes the first v_1 lines of the given task, then the second programmer writes v_2 more lines of the given task, and so on. In the end, the last programmer writes the remaining lines of the code. Let's call a plan good, if all the written lines of the task contain at most b bugs in total.
Your task is to determine how many distinct good plans are there. As the number of plans can be large, print the remainder of this number modulo given positive integer mod.
-----Input-----
The first line contains four integers n, m, b, mod (1 ≤ n, m ≤ 500, 0 ≤ b ≤ 500; 1 ≤ mod ≤ 10^9 + 7) — the number of programmers, the number of lines of code in the task, the maximum total number of bugs respectively and the modulo you should use when printing the answer.
The next line contains n space-separated integers a_1, a_2, ..., a_{n} (0 ≤ a_{i} ≤ 500) — the number of bugs per line for each programmer.
-----Output-----
Print a single integer — the answer to the problem modulo mod.
-----Examples-----
Input
3 3 3 100
1 1 1
Output
10
Input
3 6 5 1000000007
1 2 3
Output
0
Input
3 5 6 11
1 2 1
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 main():
n, m, b, mod = list(map(int, input().split()))
row_zero = [1] + [0] * b
b += 1
dp = [[0] * b for _ in range(m)]
for a in list(map(int, input().split())):
cur = row_zero
for nxt in dp:
for i, u in zip(list(range(a, b)), cur):
nxt[i] = (nxt[i] + u) % mod
cur = nxt
print(sum(dp[-1]) % mod)
def __starting_point():
main()
__starting_point()
``` | vfc_24563 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/543/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 3 3 100\n1 1 1\n",
"output": "10\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3965 | Solve the following coding problem using the programming language python:
You are given a text consisting of n lines. Each line contains some space-separated words, consisting of lowercase English letters.
We define a syllable as a string that contains exactly one vowel and any arbitrary number (possibly none) of consonants. In English alphabet following letters are considered to be vowels: 'a', 'e', 'i', 'o', 'u' and 'y'.
Each word of the text that contains at least one vowel can be divided into syllables. Each character should be a part of exactly one syllable. For example, the word "mamma" can be divided into syllables as "ma" and "mma", "mam" and "ma", and "mamm" and "a". Words that consist of only consonants should be ignored.
The verse patterns for the given text is a sequence of n integers p_1, p_2, ..., p_{n}. Text matches the given verse pattern if for each i from 1 to n one can divide words of the i-th line in syllables in such a way that the total number of syllables is equal to p_{i}.
You are given the text and the verse pattern. Check, if the given text matches the given verse pattern.
-----Input-----
The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the number of lines in the text.
The second line contains integers p_1, ..., p_{n} (0 ≤ p_{i} ≤ 100) — the verse pattern.
Next n lines contain the text itself. Text consists of lowercase English letters and spaces. It's guaranteed that all lines are non-empty, each line starts and ends with a letter and words are separated by exactly one space. The length of each line doesn't exceed 100 characters.
-----Output-----
If the given text matches the given verse pattern, then print "YES" (without quotes) in the only line of the output. Otherwise, print "NO" (without quotes).
-----Examples-----
Input
3
2 2 3
intel
code
ch allenge
Output
YES
Input
4
1 2 3 1
a
bcdefghi
jklmnopqrstu
vwxyz
Output
NO
Input
4
13 11 15 15
to be or not to be that is the question
whether tis nobler in the mind to suffer
the slings and arrows of outrageous fortune
or to take arms against a sea of troubles
Output
YES
-----Note-----
In the first sample, one can split words into syllables in the following way: in-tel
co-de
ch al-len-ge
Since the word "ch" in the third line doesn't contain vowels, we can ignore it. As the result we get 2 syllabels in first two lines and 3 syllables in the third one.
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
def main():
n = int(input())
ps = [int(x) for x in input().split()]
v = set('aeiouy')
for p in ps:
s = input()
ss = sum(1 for x in s if x in v)
if ss != p:
print('NO')
return
print('YES')
def __starting_point():
main()
__starting_point()
``` | vfc_24567 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/722/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n2 2 3\nintel\ncode\nch allenge\n",
"output": "YES\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3966 | Solve the following coding problem using the programming language python:
Appleman and Toastman play a game. Initially Appleman gives one group of n numbers to the Toastman, then they start to complete the following tasks: Each time Toastman gets a group of numbers, he sums up all the numbers and adds this sum to the score. Then he gives the group to the Appleman. Each time Appleman gets a group consisting of a single number, he throws this group out. Each time Appleman gets a group consisting of more than one number, he splits the group into two non-empty groups (he can do it in any way) and gives each of them to Toastman.
After guys complete all the tasks they look at the score value. What is the maximum possible value of score they can get?
-----Input-----
The first line contains a single integer n (1 ≤ n ≤ 3·10^5). The second line contains n integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^6) — the initial group that is given to Toastman.
-----Output-----
Print a single integer — the largest possible score.
-----Examples-----
Input
3
3 1 5
Output
26
Input
1
10
Output
10
-----Note-----
Consider the following situation in the first example. Initially Toastman gets group [3, 1, 5] and adds 9 to the score, then he give the group to Appleman. Appleman splits group [3, 1, 5] into two groups: [3, 5] and [1]. Both of them should be given to Toastman. When Toastman receives group [1], he adds 1 to score and gives the group to Appleman (he will throw it out). When Toastman receives group [3, 5], he adds 8 to the score and gives the group to Appleman. Appleman splits [3, 5] in the only possible way: [5] and [3]. Then he gives both groups to Toastman. When Toastman receives [5], he adds 5 to the score and gives the group to Appleman (he will throws it out). When Toastman receives [3], he adds 3 to the score and gives the group to Appleman (he will throws it out). Finally Toastman have added 9 + 1 + 8 + 5 + 3 = 26 to the score. This is the optimal sequence of actions.
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 = sorted(list(map(int, input().split())))
ans = 0
if n == 1:
ans = a[0]
else:
mult = 2
for i in range(n - 1):
ans += mult * a[i]
mult += 1
ans += (mult - 1) * a[-1]
print(ans)
``` | vfc_24571 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/461/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n3 1 5\n",
"output": "26\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3967 | Solve the following coding problem using the programming language python:
Vladimir wants to modernize partitions in his office. To make the office more comfortable he decided to remove a partition and plant several bamboos in a row. He thinks it would be nice if there are n bamboos in a row, and the i-th from the left is a_{i} meters high.
Vladimir has just planted n bamboos in a row, each of which has height 0 meters right now, but they grow 1 meter each day. In order to make the partition nice Vladimir can cut each bamboo once at any height (no greater that the height of the bamboo), and then the bamboo will stop growing.
Vladimir wants to check the bamboos each d days (i.e. d days after he planted, then after 2d days and so on), and cut the bamboos that reached the required height. Vladimir wants the total length of bamboo parts he will cut off to be no greater than k meters.
What is the maximum value d he can choose so that he can achieve what he wants without cutting off more than k meters of bamboo?
-----Input-----
The first line contains two integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10^11) — the number of bamboos and the maximum total length of cut parts, in meters.
The second line contains n integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9) — the required heights of bamboos, in meters.
-----Output-----
Print a single integer — the maximum value of d such that Vladimir can reach his goal.
-----Examples-----
Input
3 4
1 3 5
Output
3
Input
3 40
10 30 50
Output
32
-----Note-----
In the first example Vladimir can check bamboos each 3 days. Then he will cut the first and the second bamboos after 3 days, and the third bamboo after 6 days. The total length of cut parts is 2 + 0 + 1 = 3 meters.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import itertools
unfold = itertools.chain.from_iterable
speedup = 400000
def jumps(a):
d = speedup
while d < a - 1:
c = (a + d - 1) // d
d = (a + c - 2) // (c - 1)
yield d
def calc(d):
return sum(d - 1 - (i - 1) % d for i in a)
def ans():
for d, pd in zip(D, D[1:]):
d -= 1
cd = calc(d)
if cd <= k:
return d
if d == pd:
continue
cpd = calc(pd)
if d - pd >= (cd - k) * (d - pd) / (cd - cpd):
return d - (cd - k) * (d - pd) / (cd - cpd)
return 1
n, k = map(int, input().split())
a = list(map(int, input().split()))
speedup = min(speedup, 2 * int(max(a) ** 0.5))
D = sorted(set(range(1, speedup + 1)).union([max(a) + k + 1]).union(set(
unfold(map(jumps, a)))), reverse=True)
print('%d' % ans())
``` | vfc_24575 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/830/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 4\n1 3 5\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 40\n10 30 50\n",
"output": "32\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "20 53\n32 64 20 41 97 50 20 66 68 22 60 74 61 97 54 80 30 72 59 18\n",
"output": "6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "100 82\n51 81 14 37 17 78 92 64 15 8 86 89 8 87 77 66 10 15 12 100 25 92 47 21 78 20 63 13 49 41 36 41 79 16 87 87 69 3 76 80 60 100 49 70 59 72 8 38 71 45 97 71 14 76 54 81 4 59 46 39 29 92 3 49 22 53 99 59 52 74 31 92 43 42 23 44 9 82 47 7 40 12 9 3 55 37 85 46 22 84 52 98 41 21 77 63 17 62 91 64\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10 99\n62 10 47 53 9 83 33 15 24 28\n",
"output": "21\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "100 7\n4 5 5 10 10 5 8 5 7 4 5 4 6 8 8 2 6 3 3 10 7 10 8 6 2 7 3 9 7 7 2 4 5 2 4 9 5 10 1 10 5 10 4 1 3 4 2 6 9 9 9 10 6 2 5 6 1 8 10 4 10 3 4 10 5 5 4 10 4 5 3 7 10 2 7 3 6 9 6 1 6 5 5 4 6 6 4 4 1 5 1 6 6 6 8 8 6 2 6 3\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3968 | Solve the following coding problem using the programming language python:
A deadly virus is sweeping across the globe! You are part of an elite group of programmers tasked with tracking the spread of the virus. You have been given the timestamps of people entering and exiting a room. Now your job is to determine how the virus will spread. Hurry up, time is of the essence!
There are $N$ people in this scenario, numbered from $1$ to $N$. Every day, the $i$th person enters and exits the room at time $s_ i$ and $t_ i$ respectively. At the beginning of the $1$st day, there are $C$ people infected with the virus, whose indices will be given in the input.
When an infected person comes into contact with an uninfected person, the uninfected person will become infected at the start of the next day. Hence, they can only start spreading the infection from the next day onward. An infected person will always remain infected.
Two people are in contact with each other if they are in the room at the same time. This includes cases where one person leaves and another person enters at the exact same time. Also, if a person enters and exits the room at the same time ($s_ i$ = $t_ i$), they are considered to be in contact with everyone in the room at that time. Due to safe-distancing requirements, no more than $50$ people can be in the room at one time.
Your job is to print the indices of the people who will be infected after $D$ days. This includes people who came into contact with an infected person on the $D$th day but will only become infected at the start of the $D+1$th day.
Given below are the visualizations for sample inputs $1$ and $2$.
Note: In sample $2$, person $2$ and $4$ will get infected after day $1$. They can only spread the infection to person $3$ and $5$ on day $2$. For $D = 1$, the infected people are $1$, $2$, $4$. If $D$ had been $2$, person $3$ and $5$ would have also been infected.
-----Input-----
The first line contains two integers, $1 \le N \le 20000$, and $1 \le D \le 50000$, the number of people and number of days respectively.
The second line contains an integer $1 \le C \le N$, the initial number of infected people, followed by $C$ integers, the indices of the infected people. Indices are from $1$ to $N$.
The next $N$ lines describe the entry and exit times of the $N$ people, in order from $1$ to $N$. Each line contains two integers, $s_ i$ and $t_ i$, the entry and exit time respectively. $0 \le s_ i \le t_ i \le 10^9$.
-----Output-----
Print a list of indices of people infected after $D$ days, in ascending order. The indices should be all on one line, separated by a single space.
-----Subtasks-----
- ($40$ Points): $N \le 5000$. $D = 1$, $C = 1$. Initially, only the person with index $1$ is infected.
- ($30$ Points): $N \le 5000$, $D \le 5$.
- ($20$ Points): $N \le 5000$.
- ($10$ Points): No additional constraint.
-----Examples-----
Sample Input 1:
9 1
1 1
5 10
1 3
11 14
5 5
10 10
3 6
6 12
7 7
4 11
Sample Output 1:
1 4 5 6 7 8 9
Sample Input 2:
5 1
1 1
3 3
2 3
1 2
3 4
4 5
Sample Output 2:
1 2 4
Sample Input 3:
5 1
1 1
3 3
3 3
4 4
4 4
5 5
Sample Output 3:
1 2
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=input().split()
ones=a.count("1")
twos=n-ones
if ones==0 or twos==0:
print(" ".join(a))
else:
print("2 1"+" 2"*(twos-1)+" 1"*(ones-1))
``` | vfc_24579 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://open.kattis.com/problems/contacttracing",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "9 1\n1 1\n5 10\n1 3\n11 14\n5 5\n10 10\n3 6\n6 12\n7 7\n4 11\n",
"output": "1 4 5 6 7 8 9\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 1\n1 1\n3 3\n2 3\n1 2\n3 4\n4 5\n",
"output": "1 2 4\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3969 | Solve the following coding problem using the programming language python:
Emuskald is an avid horticulturist and owns the world's longest greenhouse — it is effectively infinite in length.
Over the years Emuskald has cultivated n plants in his greenhouse, of m different plant species numbered from 1 to m. His greenhouse is very narrow and can be viewed as an infinite line, with each plant occupying a single point on that line.
Emuskald has discovered that each species thrives at a different temperature, so he wants to arrange m - 1 borders that would divide the greenhouse into m sections numbered from 1 to m from left to right with each section housing a single species. He is free to place the borders, but in the end all of the i-th species plants must reside in i-th section from the left.
Of course, it is not always possible to place the borders in such way, so Emuskald needs to replant some of his plants. He can remove each plant from its position and place it anywhere in the greenhouse (at any real coordinate) with no plant already in it. Since replanting is a lot of stress for the plants, help Emuskald find the minimum number of plants he has to replant to be able to place the borders.
-----Input-----
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 5000, n ≥ m), the number of plants and the number of different species. Each of the following n lines contain two space-separated numbers: one integer number s_{i} (1 ≤ s_{i} ≤ m), and one real number x_{i} (0 ≤ x_{i} ≤ 10^9), the species and position of the i-th plant. Each x_{i} will contain no more than 6 digits after the decimal point.
It is guaranteed that all x_{i} are different; there is at least one plant of each species; the plants are given in order "from left to the right", that is in the ascending order of their x_{i} coordinates (x_{i} < x_{i} + 1, 1 ≤ i < n).
-----Output-----
Output a single integer — the minimum number of plants to be replanted.
-----Examples-----
Input
3 2
2 1
1 2.0
1 3.100
Output
1
Input
3 3
1 5.0
2 5.5
3 6.0
Output
0
Input
6 3
1 14.284235
2 17.921382
1 20.328172
3 20.842331
1 25.790145
1 27.204125
Output
2
-----Note-----
In the first test case, Emuskald can replant the first plant to the right of the last plant, so the answer is 1.
In the second test case, the species are already in the correct order, so no replanting is needed.
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())
t = [int(input().split()[0]) for i in range(n)]
p = [0] * (m + 1)
for i, j in enumerate(t): p[j] = min(p[j], min(p[: j])) - 1
print(n + min(p))
``` | vfc_24583 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/269/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 2\n2 1\n1 2.0\n1 3.100\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 3\n1 5.0\n2 5.5\n3 6.0\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6 3\n1 14.284235\n2 17.921382\n1 20.328172\n3 20.842331\n1 25.790145\n1 27.204125\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 1\n1 0\n",
"output": "0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3970 | Solve the following coding problem using the programming language python:
A k-multiple free set is a set of integers where there is no pair of integers where one is equal to another integer multiplied by k. That is, there are no two integers x and y (x < y) from the set, such that y = x·k.
You're given a set of n distinct positive integers. Your task is to find the size of it's largest k-multiple free subset.
-----Input-----
The first line of the input contains two integers n and k (1 ≤ n ≤ 10^5, 1 ≤ k ≤ 10^9). The next line contains a list of n distinct positive integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9).
All the numbers in the lines are separated by single spaces.
-----Output-----
On the only line of the output print the size of the largest k-multiple free subset of {a_1, a_2, ..., a_{n}}.
-----Examples-----
Input
6 2
2 3 6 5 4 10
Output
3
-----Note-----
In the sample input one of the possible maximum 2-multiple free subsets is {4, 5, 6}.
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())
t = list(map(int, input().split()))
if k == 1: print(len(set(t)))
else:
p = [set() for i in range(30)]
for i in t:
j = 0
while i % k == 0:
i //= k
j += 1
p[j].add(i)
for j in range(1, 30):
p[j] -= p[j - 1]
print(sum(len(i) for i in p))
``` | vfc_24587 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/274/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6 2\n2 3 6 5 4 10\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10 2\n1 2 3 4 5 6 7 8 9 10\n",
"output": "6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 1\n1\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "100 2\n191 17 61 40 77 95 128 88 26 69 79 10 131 106 142 152 68 39 182 53 83 81 6 89 65 148 33 22 5 47 107 121 52 163 150 158 189 118 75 180 177 176 112 167 140 184 29 166 25 46 169 145 187 123 196 18 115 126 155 100 63 58 159 19 173 113 133 60 130 161 76 157 93 199 50 97 15 67 109 164 99 149 3 137 153 136 56 43 103 170 13 183 194 72 9 181 86 30 91 36\n",
"output": "79\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "100 3\n13 38 137 24 46 192 33 8 170 141 118 57 198 133 112 176 40 36 91 130 166 72 123 28 82 180 134 52 64 107 97 79 199 184 158 22 181 163 98 7 88 41 73 87 167 109 15 173 153 70 50 119 139 56 17 152 84 161 11 116 31 187 143 196 27 102 132 126 149 63 146 168 67 48 53 120 20 105 155 10 128 47 23 6 94 3 113 65 44 179 189 99 75 34 111 193 60 145 171 77\n",
"output": "87\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "12 400000000\n1 400000000 800000000 2 3 4 5 6 7 8 9 10\n",
"output": "10\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3971 | Solve the following coding problem using the programming language python:
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it a_{k}) and delete it, at that all elements equal to a_{k} + 1 and a_{k} - 1 also must be deleted from the sequence. That step brings a_{k} points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
-----Input-----
The first line contains integer n (1 ≤ n ≤ 10^5) that shows how many numbers are in Alex's sequence.
The second line contains n integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^5).
-----Output-----
Print a single integer — the maximum number of points that Alex can earn.
-----Examples-----
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
-----Note-----
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
"""
Codeforces Contest 260 Div 1 Problem A
Author : chaotic_iak
Language: Python 3.3.4
"""
def main():
n, = read()
ar = read()
a = [0] * 100001
for i in ar: a[i] += 1
dp = [0] * 100001
dp[1] = a[1]
for i in range(2, 100001):
dp[i] = max(a[i] * i + dp[i-2], dp[i-1])
print(dp[-1])
################################### NON-SOLUTION STUFF BELOW
def read(mode=2):
# 0: String
# 1: List of strings
# 2: List of integers
inputs = input().strip()
if mode == 0: return inputs
if mode == 1: return inputs.split()
if mode == 2: return map(int, inputs.split())
def write(s="\n"):
if isinstance(s, list): s = " ".join(map(str, s))
s = str(s)
print(s, end="")
main()
``` | vfc_24591 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/455/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n1 2\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n1 2 3\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "9\n1 2 1 3 2 2 2 2 3\n",
"output": "10\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n3 3 4 5 4\n",
"output": "11\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n5 3 5 3 4\n",
"output": "16\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3974 | Solve the following coding problem using the programming language python:
Polycarpus just has been out of luck lately! As soon as he found a job in the "Binary Cat" cafe, the club got burgled. All ice-cream was stolen.
On the burglary night Polycarpus kept a careful record of all club visitors. Each time a visitor entered the club, Polycarpus put down character "+" in his notes. Similarly, each time a visitor left the club, Polycarpus put character "-" in his notes. We know that all cases of going in and out happened consecutively, that is, no two events happened at the same time. Polycarpus doesn't remember whether there was somebody in the club at the moment when his shift begun and at the moment when it ended.
Right now the police wonders what minimum number of distinct people Polycarpus could have seen. Assume that he sees anybody coming in or out of the club. Each person could have come in or out an arbitrary number of times.
-----Input-----
The only line of the input contains a sequence of characters "+" and "-", the characters are written one after another without any separators. The characters are written in the order, in which the corresponding events occurred. The given sequence has length from 1 to 300 characters, inclusive.
-----Output-----
Print the sought minimum number of people
-----Examples-----
Input
+-+-+
Output
1
Input
---
Output
3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
m,p,c=0,0,0
s=(input())
for i in s:
if i=='-':
c-=1
else:
c+=1
m=min(m,c)
p=max(p,c)
print(p-m)
``` | vfc_24603 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/245/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "+-+-+\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "---\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "-\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "--\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3975 | Solve the following coding problem using the programming language python:
Natasha travels around Mars in the Mars rover. But suddenly it broke down, namely — the logical scheme inside it. The scheme is an undirected tree (connected acyclic graph) with a root in the vertex $1$, in which every leaf (excluding root) is an input, and all other vertices are logical elements, including the root, which is output. One bit is fed to each input. One bit is returned at the output.
There are four types of logical elements: AND ($2$ inputs), OR ($2$ inputs), XOR ($2$ inputs), NOT ($1$ input). Logical elements take values from their direct descendants (inputs) and return the result of the function they perform. Natasha knows the logical scheme of the Mars rover, as well as the fact that only one input is broken. In order to fix the Mars rover, she needs to change the value on this input.
For each input, determine what the output will be if Natasha changes this input.
-----Input-----
The first line contains a single integer $n$ ($2 \le n \le 10^6$) — the number of vertices in the graph (both inputs and elements).
The $i$-th of the next $n$ lines contains a description of $i$-th vertex: the first word "AND", "OR", "XOR", "NOT" or "IN" (means the input of the scheme) is the vertex type. If this vertex is "IN", then the value of this input follows ($0$ or $1$), otherwise follow the indices of input vertices of this element: "AND", "OR", "XOR" have $2$ inputs, whereas "NOT" has $1$ input. The vertices are numbered from one.
It is guaranteed that input data contains a correct logical scheme with an output produced by the vertex $1$.
-----Output-----
Print a string of characters '0' and '1' (without quotes) — answers to the problem for each input in the ascending order of their vertex indices.
-----Example-----
Input
10
AND 9 4
IN 1
IN 1
XOR 6 5
AND 3 7
IN 0
NOT 10
IN 1
IN 1
AND 2 8
Output
10110
-----Note-----
The original scheme from the example (before the input is changed):
[Image]
Green indicates bits '1', yellow indicates bits '0'.
If Natasha changes the input bit $2$ to $0$, then the output will be $1$.
If Natasha changes the input bit $3$ to $0$, then the output will be $0$.
If Natasha changes the input bit $6$ to $1$, then the output will be $1$.
If Natasha changes the input bit $8$ to $0$, then the output will be $1$.
If Natasha changes the input bit $9$ to $0$, then the output will be $0$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
n=int(input())
f={
'AND':(lambda a:a[0]&a[1]),
'OR':(lambda a:a[0]|a[1]),
'XOR':(lambda a:a[0]^a[1]),
'NOT':(lambda a:a[0]^1),
}
g={'0':(lambda a:0), '1':(lambda a:1)}
d=[(g[v[0]],[]) if o=='IN' else (f[o],[int(a)-1 for a in v]) for o,*v in map(str.split,sys.stdin.read().strip().split('\n'))]
t=[0]
for i in t:
t.extend(d[i][1])
v=[0 for _ in range(n)]
for i in t[::-1]:
o,a=d[i]
v[i]=o([v[x] for x in a])
f=[0 for _ in range(n)]
f[0]=1
for i in t:
if f[i]<1: continue
o,a=d[i]
b=[v[x]for x in a]
assert o(b)==v[i]
for j,k in enumerate(a):
b[j]^=1
f[k]=(o(b)!=v[i])
b[j]^=1
print(''.join(str(f[i]^v[0]) for i in range(n) if not d[i][1]))
``` | vfc_24607 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1010/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "10\nAND 9 4\nIN 1\nIN 1\nXOR 6 5\nAND 3 7\nIN 0\nNOT 10\nIN 1\nIN 1\nAND 2 8\n",
"output": "10110",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\nAND 2 3\nIN 0\nIN 0\n",
"output": "00",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\nAND 2 3\nIN 1\nIN 0\n",
"output": "01",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3976 | Solve the following coding problem using the programming language python:
Sereja has two sequences a and b and number p. Sequence a consists of n integers a_1, a_2, ..., a_{n}. Similarly, sequence b consists of m integers b_1, b_2, ..., b_{m}. As usual, Sereja studies the sequences he has. Today he wants to find the number of positions q (q + (m - 1)·p ≤ n; q ≥ 1), such that sequence b can be obtained from sequence a_{q}, a_{q} + p, a_{q} + 2p, ..., a_{q} + (m - 1)p by rearranging elements.
Sereja needs to rush to the gym, so he asked to find all the described positions of q.
-----Input-----
The first line contains three integers n, m and p (1 ≤ n, m ≤ 2·10^5, 1 ≤ p ≤ 2·10^5). The next line contains n integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9). The next line contains m integers b_1, b_2, ..., b_{m} (1 ≤ b_{i} ≤ 10^9).
-----Output-----
In the first line print the number of valid qs. In the second line, print the valid values in the increasing order.
-----Examples-----
Input
5 3 1
1 2 3 2 1
1 2 3
Output
2
1 3
Input
6 3 2
1 3 2 2 3 1
1 2 3
Output
2
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 collections import defaultdict
n, m, p = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
u = defaultdict(int)
for i in b: u[i] += 1
ans = []
for q in range(p):
c = a[q: n: p]
if len(c) < m: break
v = defaultdict(int)
for i in c[: m]: v[i] += 1
d = q + 1
if u == v: ans.append(d)
for j, k in zip(c[: len(c) - m], c[m: ]):
v[j] -= 1
if v[j] == 0: v.pop(j)
v[k] += 1
d += p
if u == v: ans.append(d)
ans.sort()
print(len(ans))
print(' '.join(map(str, ans)))
``` | vfc_24611 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/367/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5 3 1\n1 2 3 2 1\n1 2 3\n",
"output": "2\n1 3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6 3 2\n1 3 2 2 3 1\n1 2 3\n",
"output": "2\n1 2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "68 16 3\n5 3 4 3 3 3 2 2 2 3 2 4 2 2 2 2 4 3 5 1 1 2 2 2 3 1 5 1 2 2 1 5 1 5 3 2 3 5 2 1 1 4 2 3 4 3 4 3 3 1 3 4 1 5 2 5 3 4 4 1 4 5 5 1 1 2 2 2\n5 4 4 3 5 1 1 2 3 2 2 1 3 3 2 2\n",
"output": "3\n2 13 15\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "44 11 4\n4 3 3 3 4 3 4 5 1 3 4 2 4 4 2 2 1 5 3 1 5 2 3 2 4 4 5 3 2 2 2 4 2 2 2 5 4 2 3 5 4 3 1 1\n4 4 1 4 4 1 2 4 2 5 4\n",
"output": "1\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "54 6 4\n5 4 1 2 2 2 1 3 3 1 5 5 2 2 2 5 4 4 1 3 4 3 4 2 1 4 2 2 4 3 3 2 5 5 3 5 2 2 1 4 2 3 5 3 5 5 5 5 1 2 5 2 4 5\n2 3 5 5 3 2\n",
"output": "3\n4 8 30\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "75 54 1\n1 1 1 5 5 4 2 1 1 1 5 1 5 1 2 1 5 3 1 2 1 3 2 3 4 1 3 5 1 1 3 5 4 1 3 4 3 3 1 2 3 3 1 4 1 4 1 4 3 2 4 3 3 1 2 4 4 4 1 3 4 1 3 1 5 4 4 1 2 3 5 1 4 4 4\n1 3 3 4 3 4 1 4 4 3 1 3 1 4 3 3 5 3 1 4 5 4 3 2 2 4 3 1 4 1 2 3 3 3 2 5 1 3 1 4 5 1 1 1 4 2 1 2 3 1 1 1 5 1\n",
"output": "3\n10 11 12\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3977 | Solve the following coding problem using the programming language python:
Hongcow is ruler of the world. As ruler of the world, he wants to make it easier for people to travel by road within their own countries.
The world can be modeled as an undirected graph with n nodes and m edges. k of the nodes are home to the governments of the k countries that make up the world.
There is at most one edge connecting any two nodes and no edge connects a node to itself. Furthermore, for any two nodes corresponding to governments, there is no path between those two nodes. Any graph that satisfies all of these conditions is stable.
Hongcow wants to add as many edges as possible to the graph while keeping it stable. Determine the maximum number of edges Hongcow can add.
-----Input-----
The first line of input will contain three integers n, m and k (1 ≤ n ≤ 1 000, 0 ≤ m ≤ 100 000, 1 ≤ k ≤ n) — the number of vertices and edges in the graph, and the number of vertices that are homes of the government.
The next line of input will contain k integers c_1, c_2, ..., c_{k} (1 ≤ c_{i} ≤ n). These integers will be pairwise distinct and denote the nodes that are home to the governments in this world.
The following m lines of input will contain two integers u_{i} and v_{i} (1 ≤ u_{i}, v_{i} ≤ n). This denotes an undirected edge between nodes u_{i} and v_{i}.
It is guaranteed that the graph described by the input is stable.
-----Output-----
Output a single integer, the maximum number of edges Hongcow can add to the graph while keeping it stable.
-----Examples-----
Input
4 1 2
1 3
1 2
Output
2
Input
3 3 1
2
1 2
1 3
2 3
Output
0
-----Note-----
For the first sample test, the graph looks like this: [Image] Vertices 1 and 3 are special. The optimal solution is to connect vertex 4 to vertices 1 and 2. This adds a total of 2 edges. We cannot add any more edges, since vertices 1 and 3 cannot have any path between them.
For the second sample test, the graph looks like this: $\infty$ We cannot add any more edges to this graph. Note that we are not allowed to add self-loops, and the graph must be simple.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def cin():
return list(map(int, input().split()))
def dfs(n):
if not C[n]:
C[n]=True
s[0]+=1
for i in B[n]:
if not C[i]:dfs(i)
n,m,k=cin()
A=cin()
A=[i-1 for i in A]
B=[list([]) for i in range(n)]
C=[False for i in range(n)]
ans=mx=0
for i in range(m):
a,b=[i-1 for i in cin()]
B[a].append(b)
B[b].append(a)
for i in range(k):
s=[0]
dfs(A[i])
ans+=s[0]*(s[0]-1)//2
mx=max(mx,s[0])
ans-=mx*(mx-1)//2
for i in range(n):
if not C[i]:
s=[0]
dfs(i)
mx+=s[0]
print(ans-m+mx*(mx-1)//2)
``` | vfc_24615 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/744/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 1 2\n1 3\n1 2\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 3 1\n2\n1 2\n1 3\n2 3\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10 3 2\n1 10\n1 2\n1 3\n4 5\n",
"output": "33\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 0 1\n1\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1000 0 1\n72\n",
"output": "499500\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3978 | Solve the following coding problem using the programming language python:
You are given a sequence of integers $a_1, a_2, \dots, a_n$. You need to paint elements in colors, so that: If we consider any color, all elements of this color must be divisible by the minimal element of this color. The number of used colors must be minimized.
For example, it's fine to paint elements $[40, 10, 60]$ in a single color, because they are all divisible by $10$. You can use any color an arbitrary amount of times (in particular, it is allowed to use a color only once). The elements painted in one color do not need to be consecutive.
For example, if $a=[6, 2, 3, 4, 12]$ then two colors are required: let's paint $6$, $3$ and $12$ in the first color ($6$, $3$ and $12$ are divisible by $3$) and paint $2$ and $4$ in the second color ($2$ and $4$ are divisible by $2$). For example, if $a=[10, 7, 15]$ then $3$ colors are required (we can simply paint each element in an unique color).
-----Input-----
The first line contains an integer $n$ ($1 \le n \le 100$), where $n$ is the length of the given sequence.
The second line contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 100$). These numbers can contain duplicates.
-----Output-----
Print the minimal number of colors to paint all the given numbers in a valid way.
-----Examples-----
Input
6
10 2 3 5 4 2
Output
3
Input
4
100 100 100 100
Output
1
Input
8
7 6 5 4 3 2 2 3
Output
4
-----Note-----
In the first example, one possible way to paint the elements in $3$ colors is:
paint in the first color the elements: $a_1=10$ and $a_4=5$, paint in the second color the element $a_3=3$, paint in the third color the elements: $a_2=2$, $a_5=4$ and $a_6=2$.
In the second example, you can use one color to paint all the elements.
In the third example, one possible way to paint the elements in $4$ colors is:
paint in the first color the elements: $a_4=4$, $a_6=2$ and $a_7=2$, paint in the second color the elements: $a_2=6$, $a_5=3$ and $a_8=3$, paint in the third color the element $a_3=5$, paint in the fourth color the element $a_1=7$.
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()
B = [0] * n
ans = 0
for i in range(n):
if B[i] == 0:
ans += 1
B[i] = 1
for j in range(n):
if A[j] % A[i] == 0:
B[j] = 1
print(ans)
``` | vfc_24619 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1209/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6\n10 2 3 5 4 2\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n100 100 100 100\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3979 | Solve the following coding problem using the programming language python:
You all know that the Library of Bookland is the largest library in the world. There are dozens of thousands of books in the library.
Some long and uninteresting story was removed...
The alphabet of Bookland is so large that its letters are denoted by positive integers. Each letter can be small or large, the large version of a letter x is denoted by x'. BSCII encoding, which is used everywhere in Bookland, is made in that way so that large letters are presented in the order of the numbers they are denoted by, and small letters are presented in the order of the numbers they are denoted by, but all large letters are before all small letters. For example, the following conditions hold: 2 < 3, 2' < 3', 3' < 2.
A word x_1, x_2, ..., x_{a} is not lexicographically greater than y_1, y_2, ..., y_{b} if one of the two following conditions holds: a ≤ b and x_1 = y_1, ..., x_{a} = y_{a}, i.e. the first word is the prefix of the second word; there is a position 1 ≤ j ≤ min(a, b), such that x_1 = y_1, ..., x_{j} - 1 = y_{j} - 1 and x_{j} < y_{j}, i.e. at the first position where the words differ the first word has a smaller letter than the second word has.
For example, the word "3' 7 5" is before the word "2 4' 6" in lexicographical order. It is said that sequence of words is in lexicographical order if each word is not lexicographically greater than the next word in the sequence.
Denis has a sequence of words consisting of small letters only. He wants to change some letters to large (let's call this process a capitalization) in such a way that the sequence of words is in lexicographical order. However, he soon realized that for some reason he can't change a single letter in a single word. He only can choose a letter and change all of its occurrences in all words to large letters. He can perform this operation any number of times with arbitrary letters of Bookland's alphabet.
Help Denis to choose which letters he needs to capitalize (make large) in order to make the sequence of words lexicographically ordered, or determine that it is impossible.
Note that some words can be equal.
-----Input-----
The first line contains two integers n and m (2 ≤ n ≤ 100 000, 1 ≤ m ≤ 100 000) — the number of words and the number of letters in Bookland's alphabet, respectively. The letters of Bookland's alphabet are denoted by integers from 1 to m.
Each of the next n lines contains a description of one word in format l_{i}, s_{i}, 1, s_{i}, 2, ..., s_{i}, l_{i} (1 ≤ l_{i} ≤ 100 000, 1 ≤ s_{i}, j ≤ m), where l_{i} is the length of the word, and s_{i}, j is the sequence of letters in the word. The words are given in the order Denis has them in the sequence.
It is guaranteed that the total length of all words is not greater than 100 000.
-----Output-----
In the first line print "Yes" (without quotes), if it is possible to capitalize some set of letters in such a way that the sequence of words becomes lexicographically ordered. Otherwise, print "No" (without quotes).
If the required is possible, in the second line print k — the number of letters Denis has to capitalize (make large), and in the third line print k distinct integers — these letters. Note that you don't need to minimize the value k.
You can print the letters in any order. If there are multiple answers, print any of them.
-----Examples-----
Input
4 3
1 2
1 1
3 1 3 2
2 1 1
Output
Yes
2
2 3
Input
6 5
2 1 2
2 1 2
3 1 2 3
2 1 5
2 4 4
2 4 4
Output
Yes
0
Input
4 3
4 3 2 2 1
3 1 1 3
3 2 3 3
2 3 1
Output
No
-----Note-----
In the first example after Denis makes letters 2 and 3 large, the sequence looks like the following: 2' 1 1 3' 2' 1 1
The condition 2' < 1 holds, so the first word is not lexicographically larger than the second word. The second word is the prefix of the third word, so the are in lexicographical order. As the first letters of the third and the fourth words are the same, and 3' < 1, then the third word is not lexicographically larger than the fourth word.
In the second example the words are in lexicographical order from the beginning, so Denis can do nothing.
In the third example there is no set of letters such that if Denis capitalizes them, the sequence becomes lexicographically ordered.
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, deque
def main():
n,m = map(int, input().split())
cap = [None]*(m+1)
same_cap = defaultdict(list)
q = deque()
def apply_cap(a, c):
if cap[a] is not None:
return cap[a] == c
q.append((a,c))
while q:
b = q.pop()
if b[1] == c:
if cap[b[0]] is None:
cap[b[0]] = c
q.extend(same_cap[b[0]])
same_cap[b[0]] = []
elif cap[b[0]]!=c:
return False
return True
def same(a,b):
same_cap[b].append((a,True))
same_cap[a].append((b,False))
if cap[a] == False:
return apply_cap(b, False)
if cap[b] == True:
return apply_cap(a, True)
return True
def process(p,c):
lp = p[0]
lc = c[0]
for i in range(1, min(lp,lc)+1):
if p[i]>c[i]:
return apply_cap(p[i], True) and apply_cap(c[i], False)
if p[i]<c[i]:
return same(p[i], c[i])
return lp<=lc
p = list(map(int, input().split()))
for i in range(n-1):
c = list(map(int, input().split()))
if not process(p, c):
print ('No')
break
p = c
else:
print ('Yes')
res = []
for i,b in enumerate(cap):
if b:
res.append(i)
print(len(res))
print(' '.join(map(str,res)))
main()
``` | vfc_24623 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/875/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 3\n1 2\n1 1\n3 1 3 2\n2 1 1\n",
"output": "Yes\n2\n2 3 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6 5\n2 1 2\n2 1 2\n3 1 2 3\n2 1 5\n2 4 4\n2 4 4\n",
"output": "Yes\n0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 3\n4 3 2 2 1\n3 1 1 3\n3 2 3 3\n2 3 1\n",
"output": "No\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 4\n3 3 4 1\n4 3 4 2 2\n4 2 1 2 3\n3 4 2 2\n",
"output": "Yes\n1\n3 ",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3980 | Solve the following coding problem using the programming language python:
Little penguin Polo likes permutations. But most of all he likes permutations of integers from 0 to n, inclusive.
For permutation p = p_0, p_1, ..., p_{n}, Polo has defined its beauty — number $(0 \oplus p_{0}) +(1 \oplus p_{1}) + \cdots +(n \oplus p_{n})$.
Expression $x \oplus y$ means applying the operation of bitwise excluding "OR" to numbers x and y. This operation exists in all modern programming languages, for example, in language C++ and Java it is represented as "^" and in Pascal — as "xor".
Help him find among all permutations of integers from 0 to n the permutation with the maximum beauty.
-----Input-----
The single line contains a positive integer n (1 ≤ n ≤ 10^6).
-----Output-----
In the first line print integer m the maximum possible beauty. In the second line print any permutation of integers from 0 to n with the beauty equal to m.
If there are several suitable permutations, you are allowed to print any of them.
-----Examples-----
Input
4
Output
20
0 2 1 4 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())
p = [i for i in range(n + 1)]
k = 1
while(2 * k <= n):
k *= 2
m = n + 1
while m > 0:
while k >= m:
k //= 2
for i in range(m - k):
if k - i - 1 >= 0:
p[k + i], p[k - i - 1] = p[k - i - 1], p[k + i]
m = k - i - 1
print(n * (n + 1))
print(' '.join(map(str, p)))
``` | vfc_24627 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/288/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n",
"output": "20\n0 2 1 4 3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "7\n",
"output": "56\n7 6 5 4 3 2 1 0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n",
"output": "2\n1 0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3981 | Solve the following coding problem using the programming language python:
After the war, the supersonic rocket became the most common public transportation.
Each supersonic rocket consists of two "engines". Each engine is a set of "power sources". The first engine has $n$ power sources, and the second one has $m$ power sources. A power source can be described as a point $(x_i, y_i)$ on a 2-D plane. All points in each engine are different.
You can manipulate each engine separately. There are two operations that you can do with each engine. You can do each operation as many times as you want. For every power source as a whole in that engine: $(x_i, y_i)$ becomes $(x_i+a, y_i+b)$, $a$ and $b$ can be any real numbers. In other words, all power sources will be shifted. For every power source as a whole in that engine: $(x_i, y_i)$ becomes $(x_i \cos \theta - y_i \sin \theta, x_i \sin \theta + y_i \cos \theta)$, $\theta$ can be any real number. In other words, all power sources will be rotated.
The engines work as follows: after the two engines are powered, their power sources are being combined (here power sources of different engines may coincide). If two power sources $A(x_a, y_a)$ and $B(x_b, y_b)$ exist, then for all real number $k$ that $0 \lt k \lt 1$, a new power source will be created $C_k(kx_a+(1-k)x_b,ky_a+(1-k)y_b)$. Then, this procedure will be repeated again with all new and old power sources. After that, the "power field" from all power sources will be generated (can be considered as an infinite set of all power sources occurred).
A supersonic rocket is "safe" if and only if after you manipulate the engines, destroying any power source and then power the engine, the power field generated won't be changed (comparing to the situation where no power source erased). Two power fields are considered the same if and only if any power source in one field belongs to the other one as well.
Given a supersonic rocket, check whether it is safe or not.
-----Input-----
The first line contains two integers $n$, $m$ ($3 \le n, m \le 10^5$) — the number of power sources in each engine.
Each of the next $n$ lines contains two integers $x_i$ and $y_i$ ($0\leq x_i, y_i\leq 10^8$) — the coordinates of the $i$-th power source in the first engine.
Each of the next $m$ lines contains two integers $x_i$ and $y_i$ ($0\leq x_i, y_i\leq 10^8$) — the coordinates of the $i$-th power source in the second engine.
It is guaranteed that there are no two or more power sources that are located in the same point in each engine.
-----Output-----
Print "YES" if the supersonic rocket is safe, otherwise "NO".
You can print each letter in an arbitrary case (upper or lower).
-----Examples-----
Input
3 4
0 0
0 2
2 0
0 2
2 2
2 0
1 1
Output
YES
Input
3 4
0 0
0 2
2 0
0 2
2 2
2 0
0 0
Output
NO
-----Note-----
The first sample: [Image] Those near pairs of blue and orange points actually coincide.
First, manipulate the first engine: use the second operation with $\theta = \pi$ (to rotate all power sources $180$ degrees).
The power sources in the first engine become $(0, 0)$, $(0, -2)$, and $(-2, 0)$. [Image]
Second, manipulate the second engine: use the first operation with $a = b = -2$.
The power sources in the second engine become $(-2, 0)$, $(0, 0)$, $(0, -2)$, and $(-1, -1)$. [Image]
You can examine that destroying any point, the power field formed by the two engines are always the solid triangle $(0, 0)$, $(-2, 0)$, $(0, -2)$.
In the second sample, no matter how you manipulate the engines, there always exists a power source in the second engine that power field will shrink if you destroy it.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
# > 0 anti-clock, < 0 clockwise, == 0 same line
def orientation(p1, p2, p3):
return (p2[0] - p1[0])*(p3[1] - p1[1]) - (p2[1] - p1[1])*(p3[0] - p1[0])
def dot(p1, p2, p3, p4):
return (p2[0]-p1[0])*(p4[0]-p3[0]) + (p2[1]-p1[1])*(p4[1]-p3[1])
def theta(p1, p2):
dx = p2[0] - p1[0]
dy = p2[1] - p1[1]
if abs(dx) < 0.1 and abs(dy) < 0.1:
t = 0
else:
t = dy/(abs(dx) + abs(dy))
if abs(t) < 0.1 ** 10:
t = 0
if dx < 0:
t = 2 - t
elif dy < 0:
t = 4 + t
return t*90
def dist_sq(p1, p2):
return (p1[0] - p2[0])*(p1[0] - p2[0]) + (p1[1] - p2[1])*(p1[1] - p2[1])
def chull(points):
# let 0 element to be smallest, reorder elements
pi = [x for x in range(len(points))]
min_y = points[0][1]
min_x = points[0][0]
min_ind = 0
for i in range(len(points)):
if points[i][1] < min_y or points[i][1] == min_y and points[i][0] < min_x:
min_y = points[i][1]
min_x = points[i][0]
min_ind = i
pi[0] = min_ind
pi[min_ind] = 0
th = [theta(points[pi[0]], points[x]) for x in range(len(points))]
pi.sort(key=lambda x: th[x])
# process equals
unique = [pi[0], pi[1]]
for i in range(2, len(pi)):
if th[pi[i]] != th[unique[-1]]:
unique.append(pi[i])
else:
if dist_sq(points[pi[0]], points[unique[-1]]) < dist_sq(points[pi[0]], points[pi[i]]):
unique[-1] = pi[i] # put max
pi = unique
stack = []
for i in range(min(len(pi), 3)):
stack.append(points[pi[i]])
if len(stack) < 3:
return stack
for i in range(3, len(pi)):
while len(stack) >= 2:
o = orientation(stack[-2], stack[-1], points[pi[i]])
if o > 0:
stack.append(points[pi[i]])
break
elif o < 0:
stack.pop()
else: # ==
if dist_sq(stack[-2], stack[-1]) < dist_sq(stack[-2], points[pi[i]]):
stack.pop()
else:
break # skip i-th point
return stack
def z_func(s):
slen, l, r = len(s), 0, 0
z = [0]*slen
z[0] = slen
for i in range(1, slen):
if i <= r: z[i] = min(r-i+1, z[i-l])
while i+z[i] < slen and s[z[i]] == s[i+z[i]]: z[i] += 1
if i+z[i]-1 > r: l, r = i, i+z[i]-1
return z
n,m = map(int, sys.stdin.readline().strip().split())
a = []
for _ in range(n):
x,y = map(int, sys.stdin.readline().strip().split())
a.append((x, y))
b = []
for _ in range(m):
x, y = map(int, sys.stdin.readline().strip().split())
b.append((x, y))
ah = chull(a)
bh = chull(b)
if len(ah) == len(bh):
if len(ah) == 2:
if dist_sq(ah[0], ah[1]) == dist_sq(bh[0], bh[1]):
print('YES')
else:
print('NO')
else:
da = []
for i in range(len(ah)):
dot_a = dot(ah[i-2], ah[i-1], ah[i-1], ah[i])
da.append((dist_sq(ah[i], ah[i-1]), dot_a))
db = []
for i in range(len(bh)):
dot_b = dot(bh[i - 2], bh[i - 1], bh[i - 1], bh[i])
db.append((dist_sq(bh[i], bh[i-1]), dot_b))
l = r = 0
daab = []
daab.extend(db)
daab.append(-1)
daab.extend(da)
daab.extend(da)
zab = z_func(daab)
found = False
for i in range(len(db)+1, len(daab)-len(db)+1):
if zab[i] == len(db):
found = True
break
if found:
print('YES')
else:
print('NO')
else:
print('NO')
``` | vfc_24631 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1017/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 4\n0 0\n0 2\n2 0\n0 2\n2 2\n2 0\n1 1\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 4\n0 0\n0 2\n2 0\n0 2\n2 2\n2 0\n0 0\n",
"output": "NO\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3982 | Solve the following coding problem using the programming language python:
In Morse code, an letter of English alphabet is represented as a string of some length from $1$ to $4$. Moreover, each Morse code representation of an English letter contains only dots and dashes. In this task, we will represent a dot with a "0" and a dash with a "1".
Because there are $2^1+2^2+2^3+2^4 = 30$ strings with length $1$ to $4$ containing only "0" and/or "1", not all of them correspond to one of the $26$ English letters. In particular, each string of "0" and/or "1" of length at most $4$ translates into a distinct English letter, except the following four strings that do not correspond to any English alphabet: "0011", "0101", "1110", and "1111".
You will work with a string $S$, which is initially empty. For $m$ times, either a dot or a dash will be appended to $S$, one at a time. Your task is to find and report, after each of these modifications to string $S$, the number of non-empty sequences of English letters that are represented with some substring of $S$ in Morse code.
Since the answers can be incredibly tremendous, print them modulo $10^9 + 7$.
-----Input-----
The first line contains an integer $m$ ($1 \leq m \leq 3\,000$) — the number of modifications to $S$.
Each of the next $m$ lines contains either a "0" (representing a dot) or a "1" (representing a dash), specifying which character should be appended to $S$.
-----Output-----
Print $m$ lines, the $i$-th of which being the answer after the $i$-th modification to $S$.
-----Examples-----
Input
3
1
1
1
Output
1
3
7
Input
5
1
0
1
0
1
Output
1
4
10
22
43
Input
9
1
1
0
0
0
1
1
0
1
Output
1
3
10
24
51
109
213
421
833
-----Note-----
Let us consider the first sample after all characters have been appended to $S$, so S is "111".
As you can see, "1", "11", and "111" all correspond to some distinct English letter. In fact, they are translated into a 'T', an 'M', and an 'O', respectively. All non-empty sequences of English letters that are represented with some substring of $S$ in Morse code, therefore, are as follows. "T" (translates into "1") "M" (translates into "11") "O" (translates into "111") "TT" (translates into "11") "TM" (translates into "111") "MT" (translates into "111") "TTT" (translates into "111")
Although unnecessary for this task, a conversion table from English alphabets into Morse code can be found here.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
MOD = 10 ** 9 + 7
BAD = ([0, 0, 1, 1], [0, 1, 0, 1], [1, 1, 1, 0], [1, 1, 1, 1])
def zfunc(s):
z = [0] * len(s)
l = r = 0
for i in range(1, len(s)):
if i <= r:
z[i] = min(r - i + 1, z[i - l])
while i + z[i] < len(s) and s[z[i]] == s[i + z[i]]:
z[i] += 1
if i + z[i] - 1 > r:
l, r = i, i + z[i] - 1
return z
n = int(input())
s = []
sm = 0
for i in range(1, n + 1):
s.append(int(input()))
cur = 0
f = [0] * (i + 1)
sum4 = f[i] = 1
for j in range(i - 1, -1, -1):
if j + 4 < i:
sum4 -= f[j + 5]
if j + 4 <= i and s[j : j + 4] in BAD:
f[j] -= f[j + 4]
f[j] = (f[j] + sum4) % MOD
sum4 += f[j]
z = zfunc(s[::-1])
new = i - max(z)
sm = (sm + sum(f[:new])) % MOD
print(sm)
``` | vfc_24635 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1129/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n1\n1\n1\n",
"output": "1\n3\n7\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3984 | Solve the following coding problem using the programming language python:
Mike and Ann are sitting in the classroom. The lesson is boring, so they decided to play an interesting game. Fortunately, all they need to play this game is a string $s$ and a number $k$ ($0 \le k < |s|$).
At the beginning of the game, players are given a substring of $s$ with left border $l$ and right border $r$, both equal to $k$ (i.e. initially $l=r=k$). Then players start to make moves one by one, according to the following rules: A player chooses $l^{\prime}$ and $r^{\prime}$ so that $l^{\prime} \le l$, $r^{\prime} \ge r$ and $s[l^{\prime}, r^{\prime}]$ is lexicographically less than $s[l, r]$. Then the player changes $l$ and $r$ in this way: $l := l^{\prime}$, $r := r^{\prime}$. Ann moves first. The player, that can't make a move loses.
Recall that a substring $s[l, r]$ ($l \le r$) of a string $s$ is a continuous segment of letters from s that starts at position $l$ and ends at position $r$. For example, "ehn" is a substring ($s[3, 5]$) of "aaaehnsvz" and "ahz" is not.
Mike and Ann were playing so enthusiastically that they did not notice the teacher approached them. Surprisingly, the teacher didn't scold them, instead of that he said, that he can figure out the winner of the game before it starts, even if he knows only $s$ and $k$.
Unfortunately, Mike and Ann are not so keen in the game theory, so they ask you to write a program, that takes $s$ and determines the winner for all possible $k$.
-----Input-----
The first line of the input contains a single string $s$ ($1 \leq |s| \leq 5 \cdot 10^5$) consisting of lowercase English letters.
-----Output-----
Print $|s|$ lines.
In the line $i$ write the name of the winner (print Mike or Ann) in the game with string $s$ and $k = i$, if both play optimally
-----Examples-----
Input
abba
Output
Mike
Ann
Ann
Mike
Input
cba
Output
Mike
Mike
Mike
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
s = input()
m = chr(ord('z') + 1)
ans = []
f = 0
for i in s:
if i > m:
ans.append('Ann')
else:
ans.append('Mike')
m = min(m, i)
print('\n'.join(ans))
``` | vfc_24643 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1220/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "abba\n",
"output": "Mike\nAnn\nAnn\nMike\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "cba\n",
"output": "Mike\nMike\nMike\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3985 | Solve the following coding problem using the programming language python:
You have written on a piece of paper an array of n positive integers a[1], a[2], ..., a[n] and m good pairs of integers (i_1, j_1), (i_2, j_2), ..., (i_{m}, j_{m}). Each good pair (i_{k}, j_{k}) meets the following conditions: i_{k} + j_{k} is an odd number and 1 ≤ i_{k} < j_{k} ≤ n.
In one operation you can perform a sequence of actions: take one of the good pairs (i_{k}, j_{k}) and some integer v (v > 1), which divides both numbers a[i_{k}] and a[j_{k}]; divide both numbers by v, i. e. perform the assignments: $a [ i_{k} ] = \frac{a [ i_{k} ]}{v}$ and $a [ j_{k} ] = \frac{a [ j_{k} ]}{v}$.
Determine the maximum number of operations you can sequentially perform on the given array. Note that one pair may be used several times in the described operations.
-----Input-----
The first line contains two space-separated integers n, m (2 ≤ n ≤ 100, 1 ≤ m ≤ 100).
The second line contains n space-separated integers a[1], a[2], ..., a[n] (1 ≤ a[i] ≤ 10^9) — the description of the array.
The following m lines contain the description of good pairs. The k-th line contains two space-separated integers i_{k}, j_{k} (1 ≤ i_{k} < j_{k} ≤ n, i_{k} + j_{k} is an odd number).
It is guaranteed that all the good pairs are distinct.
-----Output-----
Output the answer for the problem.
-----Examples-----
Input
3 2
8 3 8
1 2
2 3
Output
0
Input
3 2
8 12 8
1 2
2 3
Output
2
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def g(i):
u[i] = 0
for j in p[i]:
if v[j] < 0 or u[v[j]] and g(v[j]):
v[j] = i
return 1
return 0
f = lambda: map(int, input().split())
n, m = f()
s = k = 0
d = [[]]
for i in f():
j = 2
t = []
while j * j <= i:
while i % j == 0:
t.append((j, k))
k += 1
i //= j
j += 1
if i > 1:
t.append((i, k))
k += 1
d.append(t)
p = [[] for i in range(k)]
for q in range(m):
a, b = f()
if b % 2: a, b = b, a
for x, i in d[a]:
for y, j in d[b]:
if x == y: p[i].append(j)
v = [-1] * k
for i in range(k):
u = [1] * k
s += g(i)
print(s)
``` | vfc_24647 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/498/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 2\n8 3 8\n1 2\n2 3\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 2\n8 12 8\n1 2\n2 3\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3986 | Solve the following coding problem using the programming language python:
Little penguin Polo adores strings. But most of all he adores strings of length n.
One day he wanted to find a string that meets the following conditions: The string consists of n lowercase English letters (that is, the string's length equals n), exactly k of these letters are distinct. No two neighbouring letters of a string coincide; that is, if we represent a string as s = s_1s_2... s_{n}, then the following inequality holds, s_{i} ≠ s_{i} + 1(1 ≤ i < n). Among all strings that meet points 1 and 2, the required string is lexicographically smallest.
Help him find such string or state that such string doesn't exist.
String x = x_1x_2... x_{p} is lexicographically less than string y = y_1y_2... y_{q}, if either p < q and x_1 = y_1, x_2 = y_2, ... , x_{p} = y_{p}, or there is such number r (r < p, r < q), that x_1 = y_1, x_2 = y_2, ... , x_{r} = y_{r} and x_{r} + 1 < y_{r} + 1. The characters of the strings are compared by their ASCII codes.
-----Input-----
A single line contains two positive integers n and k (1 ≤ n ≤ 10^6, 1 ≤ k ≤ 26) — the string's length and the number of distinct letters.
-----Output-----
In a single line print the required string. If there isn't such string, print "-1" (without the quotes).
-----Examples-----
Input
7 4
Output
ababacd
Input
4 7
Output
-1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import string
rd = lambda: list(map(int, input().split()))
n, k = rd()
if k>26 or k>n or k==1 and n>1:
print(-1)
elif k==1 and n==1:
print('a')
else:
print(('ab'*(n+1>>1))[:n-k+2]+string.ascii_lowercase[2:k])
``` | vfc_24651 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/288/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7 4\n",
"output": "ababacd\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 7\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10 5\n",
"output": "abababacde\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "47 2\n",
"output": "abababababababababababababababababababababababa\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3988 | Solve the following coding problem using the programming language python:
Vasya has a graph containing both directed (oriented) and undirected (non-oriented) edges. There can be multiple edges between a pair of vertices.
Vasya has picked a vertex s from the graph. Now Vasya wants to create two separate plans:
to orient each undirected edge in one of two possible directions to maximize number of vertices reachable from vertex s; to orient each undirected edge in one of two possible directions to minimize number of vertices reachable from vertex s.
In each of two plans each undirected edge must become directed. For an edge chosen directions can differ in two plans.
Help Vasya find the plans.
-----Input-----
The first line contains three integers n, m and s (2 ≤ n ≤ 3·10^5, 1 ≤ m ≤ 3·10^5, 1 ≤ s ≤ n) — number of vertices and edges in the graph, and the vertex Vasya has picked.
The following m lines contain information about the graph edges. Each line contains three integers t_{i}, u_{i} and v_{i} (1 ≤ t_{i} ≤ 2, 1 ≤ u_{i}, v_{i} ≤ n, u_{i} ≠ v_{i}) — edge type and vertices connected by the edge. If t_{i} = 1 then the edge is directed and goes from the vertex u_{i} to the vertex v_{i}. If t_{i} = 2 then the edge is undirected and it connects the vertices u_{i} and v_{i}.
It is guaranteed that there is at least one undirected edge in the graph.
-----Output-----
The first two lines should describe the plan which maximizes the number of reachable vertices. The lines three and four should describe the plan which minimizes the number of reachable vertices.
A description of each plan should start with a line containing the number of reachable vertices. The second line of a plan should consist of f symbols '+' and '-', where f is the number of undirected edges in the initial graph. Print '+' as the j-th symbol of the string if the j-th undirected edge (u, v) from the input should be oriented from u to v. Print '-' to signify the opposite direction (from v to u). Consider undirected edges to be numbered in the same order they are given in the input.
If there are multiple solutions, print any of them.
-----Examples-----
Input
2 2 1
1 1 2
2 2 1
Output
2
-
2
+
Input
6 6 3
2 2 6
1 4 5
2 3 4
1 4 1
1 3 1
2 2 3
Output
6
++-
2
+-+
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def put():
return list(map(int, input().split()))
def dfs(x,flag=1):
s,vis,ans = [x],[0]*n,['+']*m
vis[x]= 1
while s:
i = s.pop()
for j,k in graph[i]:
if vis[j]==0:
if k*flag<0:
ans[abs(k)-1]='-'
elif k*flag>0:
ans[abs(k)-1]='+'
if flag==1 or k==0:
s.append(j)
vis[j]=1
return ''.join(ans), sum(vis)
n,m,s = put()
graph = [[] for i in range(n)]
k=1
for _ in range(m):
z,x,y = put()
x,y = x-1,y-1
if z==1:
graph[x].append((y, 0))
else:
graph[x].append((y, k))
graph[y].append((x,-k))
k+=1
m = k-1
x,y = dfs(s-1, 1)
print(y)
print(x)
x,y = dfs(s-1,-1)
print(y)
print(x)
``` | vfc_24659 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/883/G",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2 2 1\n1 1 2\n2 2 1\n",
"output": "2\n-\n2\n+\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6 6 3\n2 2 6\n1 4 5\n2 3 4\n1 4 1\n1 3 1\n2 2 3\n",
"output": "6\n++-\n2\n+-+\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 5 5\n2 5 3\n1 2 3\n1 4 5\n2 5 2\n1 2 1\n",
"output": "4\n++\n1\n--\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "13 18 9\n2 3 10\n1 12 10\n1 11 4\n2 2 8\n1 5 1\n1 7 12\n1 5 13\n1 9 7\n1 10 11\n2 3 12\n1 9 2\n1 3 9\n1 8 12\n2 11 3\n1 3 1\n1 8 4\n2 9 11\n1 12 13\n",
"output": "11\n++-++\n8\n+-+-+\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3989 | Solve the following coding problem using the programming language python:
You have number a, whose decimal representation quite luckily contains digits 1, 6, 8, 9. Rearrange the digits in its decimal representation so that the resulting number will be divisible by 7.
Number a doesn't contain any leading zeroes and contains digits 1, 6, 8, 9 (it also can contain another digits). The resulting number also mustn't contain any leading zeroes.
-----Input-----
The first line contains positive integer a in the decimal record. It is guaranteed that the record of number a contains digits: 1, 6, 8, 9. Number a doesn't contain any leading zeroes. The decimal representation of number a contains at least 4 and at most 10^6 characters.
-----Output-----
Print a number in the decimal notation without leading zeroes — the result of the permutation.
If it is impossible to rearrange the digits of the number a in the required manner, print 0.
-----Examples-----
Input
1689
Output
1869
Input
18906
Output
18690
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def end(x) :
if x == 0 :
return "1869";
if x == 6 :
return "1968";
if x == 5 :
return "1689";
if x == 4 :
return "6891";
if x == 3 :
return "1689";
if x == 2 :
return "1986";
if x == 1 :
return "1896";
d = [0] * 10;
for c in input() :
d[int(c)] += 1;
for i in [1,6,8,9] :
d[i] -= 1;
s = "";
ost = 0;
for i in range(10) :
for j in range(d[i]):
ost = (ost * 10 + i) % 7;
ost = (1869, 1896, 1986, 1698, 6198, 1689, 1968)[ost * 10000 % 7];
for c in (1,2,3,4,5,6,7,8,9) :
s += str(c) * d[c];
print((s + str(ost) + "0" * d[0]));
``` | vfc_24663 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/375/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "1689\n",
"output": "1869\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "18906\n",
"output": "18690\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2419323689\n",
"output": "2432391689\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "8589157262\n",
"output": "5857221986\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3990 | Solve the following coding problem using the programming language python:
In Absurdistan, there are n towns (numbered 1 through n) and m bidirectional railways. There is also an absurdly simple road network — for each pair of different towns x and y, there is a bidirectional road between towns x and y if and only if there is no railway between them. Travelling to a different town using one railway or one road always takes exactly one hour.
A train and a bus leave town 1 at the same time. They both have the same destination, town n, and don't make any stops on the way (but they can wait in town n). The train can move only along railways and the bus can move only along roads.
You've been asked to plan out routes for the vehicles; each route can use any road/railway multiple times. One of the most important aspects to consider is safety — in order to avoid accidents at railway crossings, the train and the bus must not arrive at the same town (except town n) simultaneously.
Under these constraints, what is the minimum number of hours needed for both vehicles to reach town n (the maximum of arrival times of the bus and the train)? Note, that bus and train are not required to arrive to the town n at the same moment of time, but are allowed to do so.
-----Input-----
The first line of the input contains two integers n and m (2 ≤ n ≤ 400, 0 ≤ m ≤ n(n - 1) / 2) — the number of towns and the number of railways respectively.
Each of the next m lines contains two integers u and v, denoting a railway between towns u and v (1 ≤ u, v ≤ n, u ≠ v).
You may assume that there is at most one railway connecting any two towns.
-----Output-----
Output one integer — the smallest possible time of the later vehicle's arrival in town n. If it's impossible for at least one of the vehicles to reach town n, output - 1.
-----Examples-----
Input
4 2
1 3
3 4
Output
2
Input
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
-1
Input
5 5
4 2
3 5
4 5
5 1
1 2
Output
3
-----Note-----
In the first sample, the train can take the route $1 \rightarrow 3 \rightarrow 4$ and the bus can take the route $1 \rightarrow 2 \rightarrow 4$. Note that they can arrive at town 4 at the same time.
In the second sample, Absurdistan is ruled by railwaymen. There are no roads, so there's no way for the bus to reach town 4.
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,m=map(int,input().split())
a=[set() for i in range(n+1)]
for i in range(m):
x,y=map(int,input().split())
a[x].add(y)
a[y].add(x)
if n not in a[1]:
t=True
else:
t=False
q=deque()
q.append(1)
z = [-1 for i in range(n+1)]
z[1] = 0
while len(q) > 0:
v = q.popleft()
for i in range(1, n+1):
if t ^ (i in a[v]):
continue
if z[i]==-1:
z[i]=z[v]+1
q.append(i)
if i == n:
print(z[i])
return
print(-1)
``` | vfc_24667 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/601/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 2\n1 3\n3 4\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 6\n1 2\n1 3\n1 4\n2 3\n2 4\n3 4\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 5\n4 2\n3 5\n4 5\n5 1\n1 2\n",
"output": "3\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3991 | Solve the following coding problem using the programming language python:
Leha decided to move to a quiet town Vičkopolis, because he was tired by living in Bankopolis. Upon arrival he immediately began to expand his network of hacked computers. During the week Leha managed to get access to n computers throughout the town. Incidentally all the computers, which were hacked by Leha, lie on the same straight line, due to the reason that there is the only one straight street in Vičkopolis.
Let's denote the coordinate system on this street. Besides let's number all the hacked computers with integers from 1 to n. So the i-th hacked computer is located at the point x_{i}. Moreover the coordinates of all computers are distinct.
Leha is determined to have a little rest after a hard week. Therefore he is going to invite his friend Noora to a restaurant. However the girl agrees to go on a date with the only one condition: Leha have to solve a simple task.
Leha should calculate a sum of F(a) for all a, where a is a non-empty subset of the set, that consists of all hacked computers. Formally, let's denote A the set of all integers from 1 to n. Noora asks the hacker to find value of the expression $\sum_{a \subseteq A, a \neq \varnothing} F(a)$. Here F(a) is calculated as the maximum among the distances between all pairs of computers from the set a. Formally, $F(a) = \operatorname{max}_{i, j \in a}|x_{i} - x_{j}|$. Since the required sum can be quite large Noora asks to find it modulo 10^9 + 7.
Though, Leha is too tired. Consequently he is not able to solve this task. Help the hacker to attend a date.
-----Input-----
The first line contains one integer n (1 ≤ n ≤ 3·10^5) denoting the number of hacked computers.
The second line contains n integers x_1, x_2, ..., x_{n} (1 ≤ x_{i} ≤ 10^9) denoting the coordinates of hacked computers. It is guaranteed that all x_{i} are distinct.
-----Output-----
Print a single integer — the required sum modulo 10^9 + 7.
-----Examples-----
Input
2
4 7
Output
3
Input
3
4 3 1
Output
9
-----Note-----
There are three non-empty subsets in the first sample test:$\{4 \}$, $\{7 \}$ and $\{4,7 \}$. The first and the second subset increase the sum by 0 and the third subset increases the sum by 7 - 4 = 3. In total the answer is 0 + 0 + 3 = 3.
There are seven non-empty subsets in the second sample test. Among them only the following subsets increase the answer: $\{4,3 \}$, $\{4,1 \}$, $\{3,1 \}$, $\{4,3,1 \}$. In total the sum is (4 - 3) + (4 - 1) + (3 - 1) + (4 - 1) = 9.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
3
# Copyright (C) 2017 Sayutin Dmitry.
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; version 3
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; If not, see <http://www.gnu.org/licenses/>.
def main():
mod = 10 ** 9 + 7
pws = [None for i in range(4 * (10 ** 5))]
pws[0] = 1
for i in range(1, (4 * (10 ** 5))):
pws[i] = 2 * pws[i - 1] % mod
n = int(input())
seq = list(map(int, input().split()))
seq.sort()
ans = 0
for i in range(n):
ans += seq[i] * (pws[i] - 1)
ans -= seq[i] * (pws[n - i - 1] - 1)
ans = ans % mod
print(ans)
main()
``` | vfc_24671 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/809/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n4 7\n",
"output": "3\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3992 | Solve the following coding problem using the programming language python:
This is the harder version of the problem. In this version, $1 \le n \le 10^6$ and $0 \leq a_i \leq 10^6$. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems
Christmas is coming, and our protagonist, Bob, is preparing a spectacular present for his long-time best friend Alice. This year, he decides to prepare $n$ boxes of chocolate, numbered from $1$ to $n$. Initially, the $i$-th box contains $a_i$ chocolate pieces.
Since Bob is a typical nice guy, he will not send Alice $n$ empty boxes. In other words, at least one of $a_1, a_2, \ldots, a_n$ is positive. Since Alice dislikes coprime sets, she will be happy only if there exists some integer $k > 1$ such that the number of pieces in each box is divisible by $k$. Note that Alice won't mind if there exists some empty boxes.
Charlie, Alice's boyfriend, also is Bob's second best friend, so he decides to help Bob by rearranging the chocolate pieces. In one second, Charlie can pick up a piece in box $i$ and put it into either box $i-1$ or box $i+1$ (if such boxes exist). Of course, he wants to help his friend as quickly as possible. Therefore, he asks you to calculate the minimum number of seconds he would need to make Alice happy.
-----Input-----
The first line contains a single integer $n$ ($1 \le n \le 10^6$) — the number of chocolate boxes.
The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($0 \le a_i \le 10^6$) — the number of chocolate pieces in the $i$-th box.
It is guaranteed that at least one of $a_1, a_2, \ldots, a_n$ is positive.
-----Output-----
If there is no way for Charlie to make Alice happy, print $-1$.
Otherwise, print a single integer $x$ — the minimum number of seconds for Charlie to help Bob make Alice happy.
-----Examples-----
Input
3
4 8 5
Output
9
Input
5
3 10 2 1 5
Output
2
Input
4
0 5 15 10
Output
0
Input
1
1
Output
-1
-----Note-----
In the first example, Charlie can move all chocolate pieces to the second box. Each box will be divisible by $17$.
In the second example, Charlie can move a piece from box $2$ to box $3$ and a piece from box $4$ to box $5$. Each box will be divisible by $3$.
In the third example, each box is already divisible by $5$.
In the fourth example, since Charlie has no available move, he cannot help Bob make Alice happy.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# 素因数分解
def prime_decomposition(n):
i = 2
table = []
while i * i <= n:
while n % i == 0:
n //= i
table.append(i)
i += 1
if n > 1:
table.append(n)
return table
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
# かけらを移動させて共通因数を持つようにする
su = sum(A)
if su == 1:
print(-1)
return
primes = sorted(set(prime_decomposition(su)))
ans = 10**18
for p in primes:
an = 0
half = p >> 1
cnt = 0
for a in A:
a %= p
cnt += a
if cnt <= half:
an += cnt
else:
if cnt < p:
an += p - cnt
else:
cnt -= p
if cnt <= half:
an += cnt
else:
an += p - cnt
if ans <= an:
break
else:
ans = min(ans, an)
print(ans)
``` | vfc_24675 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1254/B2",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n4 8 5\n",
"output": "9\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n3 10 2 1 5\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3993 | Solve the following coding problem using the programming language python:
Recently, Tokitsukaze found an interesting game. Tokitsukaze had $n$ items at the beginning of this game. However, she thought there were too many items, so now she wants to discard $m$ ($1 \le m \le n$) special items of them.
These $n$ items are marked with indices from $1$ to $n$. In the beginning, the item with index $i$ is placed on the $i$-th position. Items are divided into several pages orderly, such that each page contains exactly $k$ positions and the last positions on the last page may be left empty.
Tokitsukaze would do the following operation: focus on the first special page that contains at least one special item, and at one time, Tokitsukaze would discard all special items on this page. After an item is discarded or moved, its old position would be empty, and then the item below it, if exists, would move up to this empty position. The movement may bring many items forward and even into previous pages, so Tokitsukaze would keep waiting until all the items stop moving, and then do the operation (i.e. check the special page and discard the special items) repeatedly until there is no item need to be discarded.
[Image] Consider the first example from the statement: $n=10$, $m=4$, $k=5$, $p=[3, 5, 7, 10]$. The are two pages. Initially, the first page is special (since it is the first page containing a special item). So Tokitsukaze discards the special items with indices $3$ and $5$. After, the first page remains to be special. It contains $[1, 2, 4, 6, 7]$, Tokitsukaze discards the special item with index $7$. After, the second page is special (since it is the first page containing a special item). It contains $[9, 10]$, Tokitsukaze discards the special item with index $10$.
Tokitsukaze wants to know the number of operations she would do in total.
-----Input-----
The first line contains three integers $n$, $m$ and $k$ ($1 \le n \le 10^{18}$, $1 \le m \le 10^5$, $1 \le m, k \le n$) — the number of items, the number of special items to be discarded and the number of positions in each page.
The second line contains $m$ distinct integers $p_1, p_2, \ldots, p_m$ ($1 \le p_1 < p_2 < \ldots < p_m \le n$) — the indices of special items which should be discarded.
-----Output-----
Print a single integer — the number of operations that Tokitsukaze would do in total.
-----Examples-----
Input
10 4 5
3 5 7 10
Output
3
Input
13 4 5
7 8 9 10
Output
1
-----Note-----
For the first example:
In the first operation, Tokitsukaze would focus on the first page $[1, 2, 3, 4, 5]$ and discard items with indices $3$ and $5$; In the second operation, Tokitsukaze would focus on the first page $[1, 2, 4, 6, 7]$ and discard item with index $7$; In the third operation, Tokitsukaze would focus on the second page $[9, 10]$ and discard item with index $10$.
For the second example, Tokitsukaze would focus on the second page $[6, 7, 8, 9, 10]$ and discard all special items at once.
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 = list(map(int,input().split()))
l = list(map(int,input().split()))
out = 0
d = 0
while m > d:
nex = l[d]
page = (nex - d - 1)//k
add = 1
while d + add < m and (page * k) < l[d + add] - d <= (page + 1) * k:
add += 1
d += add
out += 1
print(out)
``` | vfc_24679 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1190/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "10 4 5\n3 5 7 10\n",
"output": "3\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3994 | Solve the following coding problem using the programming language python:
It is a holiday season, and Koala is decorating his house with cool lights! He owns $n$ lights, all of which flash periodically.
After taking a quick glance at them, Koala realizes that each of his lights can be described with two parameters $a_i$ and $b_i$. Light with parameters $a_i$ and $b_i$ will toggle (on to off, or off to on) every $a_i$ seconds starting from the $b_i$-th second. In other words, it will toggle at the moments $b_i$, $b_i + a_i$, $b_i + 2 \cdot a_i$ and so on.
You know for each light whether it's initially on or off and its corresponding parameters $a_i$ and $b_i$. Koala is wondering what is the maximum number of lights that will ever be on at the same time. So you need to find that out.
[Image] Here is a graphic for the first example.
-----Input-----
The first line contains a single integer $n$ ($1 \le n \le 100$), the number of lights.
The next line contains a string $s$ of $n$ characters. The $i$-th character is "1", if the $i$-th lamp is initially on. Otherwise, $i$-th character is "0".
The $i$-th of the following $n$ lines contains two integers $a_i$ and $b_i$ ($1 \le a_i, b_i \le 5$) — the parameters of the $i$-th light.
-----Output-----
Print a single integer — the maximum number of lights that will ever be on at the same time.
-----Examples-----
Input
3
101
3 3
3 2
3 1
Output
2
Input
4
1111
3 4
5 2
3 1
3 2
Output
4
Input
6
011100
5 3
5 5
2 4
3 5
4 2
1 5
Output
6
-----Note-----
For first example, the lamps' states are shown in the picture above. The largest number of simultaneously on lamps is $2$ (e.g. at the moment $2$).
In the second example, all lights are initially on. 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 = int(input())
s = input()
used = [0] * n
for i in range(n):
if s[i] == '0':
used[i] = False
else:
used[i] = True
a = [0] * n
b = [0] * n
for i in range(n):
a[i], b[i] = list(map(int, input().split()))
ans = 0
for time in range(500):
for i in range(n):
if time >= b[i] and (time - b[i]) % a[i] == 0:
used[i] = not used[i]
cnt = 0
for i in range(n):
if used[i]:
cnt += 1
ans = max(ans, cnt)
print(ans)
``` | vfc_24683 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1209/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n101\n3 3\n3 2\n3 1\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n1111\n3 4\n5 2\n3 1\n3 2\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\n011100\n5 3\n5 5\n2 4\n3 5\n4 2\n1 5\n",
"output": "6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n0\n1 5\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3995 | Solve the following coding problem using the programming language python:
Let $s$ be some string consisting of symbols "0" or "1". Let's call a string $t$ a substring of string $s$, if there exists such number $1 \leq l \leq |s| - |t| + 1$ that $t = s_l s_{l+1} \ldots s_{l + |t| - 1}$. Let's call a substring $t$ of string $s$ unique, if there exist only one such $l$.
For example, let $s = $"1010111". A string $t = $"010" is an unique substring of $s$, because $l = 2$ is the only one suitable number. But, for example $t = $"10" isn't a unique substring of $s$, because $l = 1$ and $l = 3$ are suitable. And for example $t =$"00" at all isn't a substring of $s$, because there is no suitable $l$.
Today Vasya solved the following problem at the informatics lesson: given a string consisting of symbols "0" and "1", the task is to find the length of its minimal unique substring. He has written a solution to this problem and wants to test it. He is asking you to help him.
You are given $2$ positive integers $n$ and $k$, such that $(n \bmod 2) = (k \bmod 2)$, where $(x \bmod 2)$ is operation of taking remainder of $x$ by dividing on $2$. Find any string $s$ consisting of $n$ symbols "0" or "1", such that the length of its minimal unique substring is equal to $k$.
-----Input-----
The first line contains two integers $n$ and $k$, separated by spaces ($1 \leq k \leq n \leq 100\,000$, $(k \bmod 2) = (n \bmod 2)$).
-----Output-----
Print a string $s$ of length $n$, consisting of symbols "0" and "1". Minimal length of the unique substring of $s$ should be equal to $k$. You can find any suitable string. It is guaranteed, that there exists at least one such string.
-----Examples-----
Input
4 4
Output
1111
Input
5 3
Output
01010
Input
7 3
Output
1011011
-----Note-----
In the first test, it's easy to see, that the only unique substring of string $s = $"1111" is all string $s$, which has length $4$.
In the second test a string $s = $"01010" has minimal unique substring $t =$"101", which has length $3$.
In the third test a string $s = $"1011011" has minimal unique substring $t =$"110", which has length $3$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n,k=list(map(int,input().split()))
x=(n-(k-1)+1)//2
STR="0"*(x-1)+"1"
ANS=STR*(n//x+1)
print(ANS[:n])
``` | vfc_24687 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1158/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 4\n",
"output": "1111",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 3\n",
"output": "01010",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3996 | Solve the following coding problem using the programming language python:
As we all know Barney's job is "PLEASE" and he has not much to do at work. That's why he started playing "cups and key". In this game there are three identical cups arranged in a line from left to right. Initially key to Barney's heart is under the middle cup. [Image]
Then at one turn Barney swaps the cup in the middle with any of other two cups randomly (he choses each with equal probability), so the chosen cup becomes the middle one. Game lasts n turns and Barney independently choses a cup to swap with the middle one within each turn, and the key always remains in the cup it was at the start.
After n-th turn Barney asks a girl to guess which cup contains the key. The girl points to the middle one but Barney was distracted while making turns and doesn't know if the key is under the middle cup. That's why he asked you to tell him the probability that girl guessed right.
Number n of game turns can be extremely large, that's why Barney did not give it to you. Instead he gave you an array a_1, a_2, ..., a_{k} such that $n = \prod_{i = 1}^{k} a_{i}$
in other words, n is multiplication of all elements of the given array.
Because of precision difficulties, Barney asked you to tell him the answer as an irreducible fraction. In other words you need to find it as a fraction p / q such that $\operatorname{gcd}(p, q) = 1$, where $gcd$ is the greatest common divisor. Since p and q can be extremely large, you only need to find the remainders of dividing each of them by 10^9 + 7.
Please note that we want $gcd$ of p and q to be 1, not $gcd$ of their remainders after dividing by 10^9 + 7.
-----Input-----
The first line of input contains a single integer k (1 ≤ k ≤ 10^5) — the number of elements in array Barney gave you.
The second line contains k integers a_1, a_2, ..., a_{k} (1 ≤ a_{i} ≤ 10^18) — the elements of the array.
-----Output-----
In the only line of output print a single string x / y where x is the remainder of dividing p by 10^9 + 7 and y is the remainder of dividing q by 10^9 + 7.
-----Examples-----
Input
1
2
Output
1/2
Input
3
1 1 1
Output
0/1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
3
class Matrix:
def __init__(self, n, m, arr=None):
self.n = n
self.m = m
self.arr = [[0] * m for i in range(n)]
if arr is not None:
for i in range(n):
for j in range(m):
self.arr[i][j] = arr[i][j]
def __mul__(self, other):
assert self.m == other.n
ans = Matrix(self.n, other.m)
for i in range(self.n):
for j in range(other.m):
for k in range(self.m):
ans.arr[i][j] = (ans.arr[i][j] + self.arr[i][k] * other.arr[k][j]) % (10 ** 9 + 7)
return ans
def __imul__(self, other):
self = self * other
return self
def __pow__(self, n):
if n == 0:
ans = Matrix(self.n, self.n)
for i in range(self.n):
ans.arr[i][i] = 1
return ans
elif n & 1 == 1:
return self * (self ** (n - 1))
else:
t = self ** (n >> 1)
return t * t
def __ipow__(self, n):
self = self ** n
return self
def __eq__(self, other):
if self.n != other.n or self.m != other.m:
return False
for i in range(self.n):
for j in range(self.m):
if self.arr[i][j] != other.arr[i][j]:
return False
return True
def fpow(a, n):
if n == 0:
return 1
elif n & 1 == 1:
return (a * fpow(a, n - 1)) % (10 ** 9 + 7)
else:
t = fpow(a, n >> 1)
return (t * t) % (10 ** 9 + 7)
transform = Matrix(2, 2, [[1, 1], [0, 4]])
mtx = transform
k = int(input())
a = list(map(int, input().split()))
"""
f = False
for j in a:
if j % 2 == 0:
f = True
break
if f:
print(a)
tp = 1
for j in a:
if f and j % 2 == 0:
j //= 2
f = False
print(j)
mtx **= j
ans = Matrix(2, 1, [[0], [1]])
ans = mtx * ans
print(ans.arr)
print("%d/%d" % (ans.arr[0][0], ans.arr[1][0]))
"""
x = 1
for j in a:
x = (x * j) % (10 ** 9 + 6)
x = (x - 1) % (10 ** 9 + 6)
if x % 2 == 0:
ans = (transform ** (x // 2)) * Matrix(2, 1, [[0], [1]])
print("%d/%d" % (ans.arr[0][0], fpow(2, x)))
else:
y = (x - 1) % (10 ** 9 + 6)
ans = (transform ** (y // 2)) * Matrix(2, 1, [[0], [1]])
print("%d/%d" % ((ans.arr[0][0] * 2 + 1) % (10 ** 9 + 7), (ans.arr[1][0] * 2) % (10 ** 9 + 7)))
``` | vfc_24691 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/696/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "1\n2\n",
"output": "1/2\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3997 | Solve the following coding problem using the programming language python:
Alyona has a tree with n vertices. The root of the tree is the vertex 1. In each vertex Alyona wrote an positive integer, in the vertex i she wrote a_{i}. Moreover, the girl wrote a positive integer to every edge of the tree (possibly, different integers on different edges).
Let's define dist(v, u) as the sum of the integers written on the edges of the simple path from v to u.
The vertex v controls the vertex u (v ≠ u) if and only if u is in the subtree of v and dist(v, u) ≤ a_{u}.
Alyona wants to settle in some vertex. In order to do this, she wants to know for each vertex v what is the number of vertices u such that v controls u.
-----Input-----
The first line contains single integer n (1 ≤ n ≤ 2·10^5).
The second line contains n integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9) — the integers written in the vertices.
The next (n - 1) lines contain two integers each. The i-th of these lines contains integers p_{i} and w_{i} (1 ≤ p_{i} ≤ n, 1 ≤ w_{i} ≤ 10^9) — the parent of the (i + 1)-th vertex in the tree and the number written on the edge between p_{i} and (i + 1).
It is guaranteed that the given graph is a tree.
-----Output-----
Print n integers — the i-th of these numbers should be equal to the number of vertices that the i-th vertex controls.
-----Examples-----
Input
5
2 5 1 4 6
1 7
1 1
3 5
3 6
Output
1 0 1 0 0
Input
5
9 7 8 6 5
1 1
2 1
3 1
4 1
Output
4 3 2 1 0
-----Note-----
In the example test case the vertex 1 controls the vertex 3, the vertex 3 controls the vertex 5 (note that is doesn't mean the vertex 1 controls the vertex 5).
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 threading
from bisect import bisect_left
n = int(input())
a = list(map(int, input().split()))
e = {}
g = [[] for i in range(n)]
d = [0]*(n+5)
ans = [0]*n
p = [0]*(n+5)
for i in range(n-1):
c, w = map(int, input().split())
c-= 1
g[c].append(i+1)
e[i+1] = w
def dfs(i, h):
nonlocal ans, a, e, g, d, p
p[h]=0
for j in g[i]:
d[h+1] = d[h]+e[j]
dfs(j, h+1)
x = bisect_left(d, d[h]-a[i], 0, h+1)
#print(x-1, i, h, d[h], d[h], a[i])
if x>=0:
p[x-1]-=1
p[h-1]+=p[h]+1
ans[i]=p[h]
def solve():
nonlocal ans
dfs(0, 0)
print(' '.join(map(str, ans)))
max_recur_size = 10**5*2 + 1000
max_stack_size = max_recur_size*500
sys.setrecursionlimit(max_recur_size)
threading.stack_size(max_stack_size)
thread = threading.Thread(target=solve)
thread.start()
``` | vfc_24695 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/739/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n2 5 1 4 6\n1 7\n1 1\n3 5\n3 6\n",
"output": "1 0 1 0 0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n9 7 8 6 5\n1 1\n2 1\n3 1\n4 1\n",
"output": "4 3 2 1 0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1 1\n1 1\n",
"output": "1 0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n40 77 65 14 86 16 2 51 62 79\n1 75\n10 86\n3 52\n6 51\n10 8\n3 61\n3 53\n5 98\n2 7\n",
"output": "1 3 0 0 0 1 0 0 0 2\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 3998 | Solve the following coding problem using the programming language python:
A group of n friends enjoys playing popular video game Toda 2. There is a rating system describing skill level of each player, initially the rating of the i-th friend is r_{i}.
The friends decided to take part in the championship as a team. But they should have equal ratings to be allowed to compose a single team consisting of all n friends. So the friends are faced with the problem: how to make all their ratings equal.
One way to change ratings is to willingly lose in some matches. Friends can form a party consisting of two to five (but not more than n) friends and play a match in the game. When the party loses, the rating of each of its members decreases by 1. A rating can't become negative, so r_{i} = 0 doesn't change after losing.
The friends can take part in multiple matches, each time making a party from any subset of friends (but remember about constraints on party size: from 2 to 5 members).
The friends want to make their ratings equal but as high as possible.
Help the friends develop a strategy of losing the matches so that all their ratings become equal and the resulting rating is maximum possible.
-----Input-----
The first line contains a single integer n (2 ≤ n ≤ 100) — the number of friends.
The second line contains n non-negative integers r_1, r_2, ..., r_{n} (0 ≤ r_{i} ≤ 100), where r_{i} is the initial rating of the i-th friend.
-----Output-----
In the first line, print a single integer R — the final rating of each of the friends.
In the second line, print integer t — the number of matches the friends have to play. Each of the following t lines should contain n characters '0' or '1', where the j-th character of the i-th line is equal to:
'0', if friend j should not play in match i, '1', if friend j should play in match i.
Each line should contain between two and five characters '1', inclusive.
The value t should not exceed 10^4, it is guaranteed that such solution exists.
Remember that you shouldn't minimize the value t, but you should maximize R. If there are multiple solutions, print any of them.
-----Examples-----
Input
5
4 5 1 7 4
Output
1
8
01010
00011
01010
10010
00011
11000
00011
11000
Input
2
1 2
Output
0
2
11
11
Input
3
1 1 1
Output
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())
L = list(map(int, input().split()))
ans = 0
M = []
while max(L) != min(L):
ans += 1
k = max(L)
if L.count(k) == 3:
s = ''
for i in range(len(L)):
if L[i] == k:
s += '1'
L[i] -= 1
else:
s += '0'
M.append(s)
else:
max_1 = 0
max_2 = 1
if L[max_1] < L[max_2]:
max_1, max_2 = max_2, max_1
for i in range(2, n):
if L[i] > L[max_1]:
max_2, max_1 = max_1, i
elif L[i] > L[max_2]:
max_2 = i
s = ''
for i in range(n):
if i == max_1 or i == max_2:
s += '1'
else:
s += '0'
M.append(s)
L[max_1] -= 1
if L[max_1] < 0:
L[max_1] = 0
L[max_2] -= 1
if L[max_2] < 0:
L[max_2] = 0
print(max(L))
print(ans)
for i in M:
print(i)
``` | vfc_24699 | {
"difficulty": "competition",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/730/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n4 5 1 7 4\n",
"output": "1\n8\n01010\n00011\n01010\n10010\n00011\n11000\n00011\n11000\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1 2\n",
"output": "0\n2\n11\n11\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n1 1 1\n",
"output": "1\n0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4001 | Solve the following coding problem using the programming language python:
Recently you have received two positive integer numbers $x$ and $y$. You forgot them, but you remembered a shuffled list containing all divisors of $x$ (including $1$ and $x$) and all divisors of $y$ (including $1$ and $y$). If $d$ is a divisor of both numbers $x$ and $y$ at the same time, there are two occurrences of $d$ in the list.
For example, if $x=4$ and $y=6$ then the given list can be any permutation of the list $[1, 2, 4, 1, 2, 3, 6]$. Some of the possible lists are: $[1, 1, 2, 4, 6, 3, 2]$, $[4, 6, 1, 1, 2, 3, 2]$ or $[1, 6, 3, 2, 4, 1, 2]$.
Your problem is to restore suitable positive integer numbers $x$ and $y$ that would yield the same list of divisors (possibly in different order).
It is guaranteed that the answer exists, i.e. the given list of divisors corresponds to some positive integers $x$ and $y$.
-----Input-----
The first line contains one integer $n$ ($2 \le n \le 128$) — the number of divisors of $x$ and $y$.
The second line of the input contains $n$ integers $d_1, d_2, \dots, d_n$ ($1 \le d_i \le 10^4$), where $d_i$ is either divisor of $x$ or divisor of $y$. If a number is divisor of both numbers $x$ and $y$ then there are two copies of this number in the list.
-----Output-----
Print two positive integer numbers $x$ and $y$ — such numbers that merged list of their divisors is the permutation of the given list of integers. It is guaranteed that the answer exists.
-----Example-----
Input
10
10 2 8 1 2 4 1 20 4 5
Output
20 8
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())
seq = sorted(list(map(int, input().split())))[::-1]
a = seq[0]
last = -1
for i in range(len(seq)):
if a % seq[i] == 0:
if last != seq[i]:
last = seq[i]
else:
b = seq[i]
break
else:
b = seq[i]
break
print(a, b)
``` | vfc_24711 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1108/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "10\n10 2 8 1 2 4 1 20 4 5\n",
"output": "20 8\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n9973 9973 1 1\n",
"output": "9973 9973\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4002 | Solve the following coding problem using the programming language python:
You are given a matrix $a$ of size $n \times m$ consisting of integers.
You can choose no more than $\left\lfloor\frac{m}{2}\right\rfloor$ elements in each row. Your task is to choose these elements in such a way that their sum is divisible by $k$ and this sum is the maximum.
In other words, you can choose no more than a half (rounded down) of elements in each row, you have to find the maximum sum of these elements divisible by $k$.
Note that you can choose zero elements (and the sum of such set is $0$).
-----Input-----
The first line of the input contains three integers $n$, $m$ and $k$ ($1 \le n, m, k \le 70$) — the number of rows in the matrix, the number of columns in the matrix and the value of $k$. The next $n$ lines contain $m$ elements each, where the $j$-th element of the $i$-th row is $a_{i, j}$ ($1 \le a_{i, j} \le 70$).
-----Output-----
Print one integer — the maximum sum divisible by $k$ you can obtain.
-----Examples-----
Input
3 4 3
1 2 3 4
5 2 2 2
7 1 1 4
Output
24
Input
5 5 4
1 2 4 2 1
3 5 1 2 4
1 5 7 1 2
3 8 7 1 2
8 4 7 1 6
Output
56
-----Note-----
In the first example, the optimal answer is $2$ and $4$ in the first row, $5$ and $2$ in the second row and $7$ and $4$ in the third row. The total sum is $2 + 4 + 5 + 2 + 7 + 4 = 24$.
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
def main():
n, m, k = map(int, input().split())
half = m // 2
se_s = []
for i in range(n):
lst = list(map(int, input().split()))
lst.sort(reverse = True)
total_sub = sum(lst[:half])
dp = [[0 for _ in range(k)] for _ in range(half + 1)]
for num2 in lst:
for i in range(half, 0, -1):
for num in dp[i - 1]:
pos = (num + num2) % k
dp[i][pos] = max(dp[i][pos], num + num2)
se_s.append(set(dp[-1]))
ans = 0
ans_sub = set([0])
for se in se_s:
se_tmp = set()
for num in se:
for num2 in ans_sub:
se_tmp.add(num + num2)
if (num + num2) % k == 0:
ans = max(ans, num + num2)
tmp = [0 for _ in range(k)]
for num in se_tmp:
tmp[num % k] = max(tmp[num % k], num)
ans_sub = set(tmp)
print(ans)
main()
``` | vfc_24715 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1433/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 4 3\n1 2 3 4\n5 2 2 2\n7 1 1 4\n",
"output": "24\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 5 4\n1 2 4 2 1\n3 5 1 2 4\n1 5 7 1 2\n3 8 7 1 2\n8 4 7 1 6\n",
"output": "56\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 1 2\n1\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 1 2\n70\n",
"output": "0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4003 | Solve the following coding problem using the programming language python:
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence $a$ consisting of $n$ integers.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence $[1, 2, 4, 3, 2]$ the answer is $4$ (you take $1$ and the sequence becomes $[2, 4, 3, 2]$, then you take the rightmost element $2$ and the sequence becomes $[2, 4, 3]$, then you take $3$ and the sequence becomes $[2, 4]$ and then you take $4$ and the sequence becomes $[2]$, the obtained increasing sequence is $[1, 2, 3, 4]$).
-----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 2 \cdot 10^5$), where $a_i$ is the $i$-th element of $a$.
-----Output-----
In the first line of the output print $k$ — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string $s$ of length $k$, where the $j$-th character of this string $s_j$ should be 'L' if you take the leftmost element during the $j$-th move and 'R' otherwise. If there are multiple answers, you can print any.
-----Examples-----
Input
5
1 2 4 3 2
Output
4
LRRR
Input
7
1 3 5 6 5 4 2
Output
6
LRLRRR
Input
3
2 2 2
Output
1
R
Input
4
1 2 4 3
Output
4
LLRR
-----Note-----
The first example is described in the problem statement.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# AC
import sys
class Main:
def __init__(self):
self.buff = None
self.index = 0
def __next__(self):
if self.buff is None or self.index == len(self.buff):
self.buff = sys.stdin.readline().split()
self.index = 0
val = self.buff[self.index]
self.index += 1
return val
def next_int(self):
return int(next(self))
def solve(self):
n = self.next_int()
x = [self.next_int() for _ in range(0, n)]
d = 0
l = 0
r = n - 1
rs = []
while l <= r:
if x[l] <= d and x[r] <= d:
break
if x[l] <= d:
rs.append('R')
d = x[r]
r -= 1
elif x[r] <= d:
rs.append('L')
d = x[l]
l += 1
elif x[r] < x[l] or l == r:
rs.append('R')
d = x[r]
r -= 1
elif x[l] < x[r]:
rs.append('L')
d = x[l]
l += 1
else:
ll = l + 1
while x[ll] > x[ll - 1]:
ll += 1
rr = r - 1
while x[rr] > x[rr + 1]:
rr -= 1
if ll - l > r - rr:
rs.append('L')
d = x[l]
l += 1
else:
rs.append('R')
d = x[r]
r -= 1
print(len(rs))
print(''.join(rs))
def __starting_point():
Main().solve()
__starting_point()
``` | vfc_24719 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1157/C2",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n1 2 4 3 2\n",
"output": "4\nLRRR\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "7\n1 3 5 6 5 4 2\n",
"output": "6\nLRLRRR\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n2 2 2\n",
"output": "1\nR\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n1 2 4 3\n",
"output": "4\nLLRR\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "15\n37504 79054 80071 95721 135743 164345 189260 190810 191657 196168 200000 200000 190810 190018 185437\n",
"output": "13\nLLLLLLRLRLLLL\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n1 2 3 4\n",
"output": "4\nLLLR\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4004 | Solve the following coding problem using the programming language python:
You are given a sequence $a_1, a_2, \dots, a_n$ consisting of $n$ integers.
You can choose any non-negative integer $D$ (i.e. $D \ge 0$), and for each $a_i$ you can:
add $D$ (only once), i. e. perform $a_i := a_i + D$, or subtract $D$ (only once), i. e. perform $a_i := a_i - D$, or leave the value of $a_i$ unchanged.
It is possible that after an operation the value $a_i$ becomes negative.
Your goal is to choose such minimum non-negative integer $D$ and perform changes in such a way, that all $a_i$ are equal (i.e. $a_1=a_2=\dots=a_n$).
Print the required $D$ or, if it is impossible to choose such value $D$, print -1.
For example, for array $[2, 8]$ the value $D=3$ is minimum possible because you can obtain the array $[5, 5]$ if you will add $D$ to $2$ and subtract $D$ from $8$. And for array $[1, 4, 7, 7]$ the value $D=3$ is also minimum possible. You can add it to $1$ and subtract it from $7$ and obtain the array $[4, 4, 4, 4]$.
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 100$) — 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 100$) — the sequence $a$.
-----Output-----
Print one integer — the minimum non-negative integer value $D$ such that if you add this value to some $a_i$, subtract this value from some $a_i$ and leave some $a_i$ without changes, all obtained values become equal.
If it is impossible to choose such value $D$, print -1.
-----Examples-----
Input
6
1 4 4 7 4 1
Output
3
Input
5
2 2 5 2 5
Output
3
Input
4
1 3 3 7
Output
-1
Input
2
2 8
Output
3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def main():
n = int(input())
a = list(sorted(set(map(int, input().split()))))
if len(a) > 3:
print(-1)
elif len(a) == 1:
print(0)
elif len(a) == 2:
d = a[1] - a[0]
if d & 1:
print(d)
else:
print(d >> 1)
else:
d = a[1] - a[0]
D = a[2] - a[1]
if d == D:
print(d)
else:
print(-1)
return 0
main()
``` | vfc_24723 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1154/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6\n1 4 4 7 4 1\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n2 2 5 2 5\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n1 3 3 7\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n2 8\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n100\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1 1\n",
"output": "0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4005 | Solve the following coding problem using the programming language python:
There is a white sheet of paper lying on a rectangle table. The sheet is a rectangle with its sides parallel to the sides of the table. If you will take a look from above and assume that the bottom left corner of the table has coordinates $(0, 0)$, and coordinate axes are left and bottom sides of the table, then the bottom left corner of the white sheet has coordinates $(x_1, y_1)$, and the top right — $(x_2, y_2)$.
After that two black sheets of paper are placed on the table. Sides of both black sheets are also parallel to the sides of the table. Coordinates of the bottom left corner of the first black sheet are $(x_3, y_3)$, and the top right — $(x_4, y_4)$. Coordinates of the bottom left corner of the second black sheet are $(x_5, y_5)$, and the top right — $(x_6, y_6)$. [Image] Example of three rectangles.
Determine if some part of the white sheet can be seen from the above after the two black sheets are placed. The part of the white sheet can be seen if there is at least one point lying not strictly inside the white sheet and strictly outside of both black sheets.
-----Input-----
The first line of the input contains four integers $x_1, y_1, x_2, y_2$ $(0 \le x_1 < x_2 \le 10^{6}, 0 \le y_1 < y_2 \le 10^{6})$ — coordinates of the bottom left and the top right corners of the white sheet.
The second line of the input contains four integers $x_3, y_3, x_4, y_4$ $(0 \le x_3 < x_4 \le 10^{6}, 0 \le y_3 < y_4 \le 10^{6})$ — coordinates of the bottom left and the top right corners of the first black sheet.
The third line of the input contains four integers $x_5, y_5, x_6, y_6$ $(0 \le x_5 < x_6 \le 10^{6}, 0 \le y_5 < y_6 \le 10^{6})$ — coordinates of the bottom left and the top right corners of the second black sheet.
The sides of each sheet of paper are parallel (perpendicular) to the coordinate axes.
-----Output-----
If some part of the white sheet can be seen from the above after the two black sheets are placed, print "YES" (without quotes). Otherwise print "NO".
-----Examples-----
Input
2 2 4 4
1 1 3 5
3 1 5 5
Output
NO
Input
3 3 7 5
0 0 4 6
0 0 7 4
Output
YES
Input
5 2 10 5
3 1 7 6
8 1 11 7
Output
YES
Input
0 0 1000000 1000000
0 0 499999 1000000
500000 0 1000000 1000000
Output
YES
-----Note-----
In the first example the white sheet is fully covered by black sheets.
In the second example the part of the white sheet can be seen after two black sheets are placed. For example, the point $(6.5, 4.5)$ lies not strictly inside the white sheet and lies strictly outside of both black sheets.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
x1, y1, x2, y2 = list(map( int, input().split() ))
x3, y3, x4, y4 = list(map( int, input().split() ))
x5, y5, x6, y6 = list(map( int, input().split() ))
covered = False
if x3 <= x1 and y3 <= y1 and x4 >= x2 and y4 >= y2:
covered = True
elif x5 <= x1 and y5 <= y1 and x6 >= x2 and y6 >= y2:
covered = True
elif x1 >= x3 and x1 >= x5 and x2 <= x4 and x2 <= x6:
if min( y4, y6 ) >= max( y3, y5 ) and min( y3, y5 ) <= y1 and max( y4, y6 ) >= y2:
covered = True
elif y1 >= y3 and y1 >= y5 and y2 <= y4 and y2 <= y6:
if min( x4, x6 ) >= max( x3, x5 ) and min( x3, x5 ) <= x1 and max( x4, x6 ) >= x2:
covered = True
print( "NO" if covered else "YES" )
``` | vfc_24727 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1216/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2 2 4 4\n1 1 3 5\n3 1 5 5\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 3 7 5\n0 0 4 6\n0 0 7 4\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 2 10 5\n3 1 7 6\n8 1 11 7\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "0 0 1000000 1000000\n0 0 499999 1000000\n500000 0 1000000 1000000\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "50 100 100000 99000\n13 4654 99999 1000000\n0 0 1000000 45653\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "0 0 1000000 1000000\n0 0 1000000 999999\n0 0 999999 1000000\n",
"output": "YES\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4006 | Solve the following coding problem using the programming language python:
Let's denote a function $f(x)$ in such a way: we add $1$ to $x$, then, while there is at least one trailing zero in the resulting number, we remove that zero. For example, $f(599) = 6$: $599 + 1 = 600 \rightarrow 60 \rightarrow 6$; $f(7) = 8$: $7 + 1 = 8$; $f(9) = 1$: $9 + 1 = 10 \rightarrow 1$; $f(10099) = 101$: $10099 + 1 = 10100 \rightarrow 1010 \rightarrow 101$.
We say that some number $y$ is reachable from $x$ if we can apply function $f$ to $x$ some (possibly zero) times so that we get $y$ as a result. For example, $102$ is reachable from $10098$ because $f(f(f(10098))) = f(f(10099)) = f(101) = 102$; and any number is reachable from itself.
You are given a number $n$; your task is to count how many different numbers are reachable from $n$.
-----Input-----
The first line contains one integer $n$ ($1 \le n \le 10^9$).
-----Output-----
Print one integer: the number of different numbers that are reachable from $n$.
-----Examples-----
Input
1098
Output
20
Input
10
Output
19
-----Note-----
The numbers that are reachable from $1098$ are:
$1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1098, 1099$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
darling = {}
x = int(input())
ans = 0
while (x not in darling):
darling[x] = 1
ans += 1
x += 1
while (x % 10 == 0):
x /= 10
print(ans)
``` | vfc_24731 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1157/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "1098\n",
"output": "20\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n",
"output": "19\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1000000000\n",
"output": "91\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n",
"output": "9\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "9\n",
"output": "9\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4007 | Solve the following coding problem using the programming language python:
There are $n$ friends who want to give gifts for the New Year to each other. Each friend should give exactly one gift and receive exactly one gift. The friend cannot give the gift to himself.
For each friend the value $f_i$ is known: it is either $f_i = 0$ if the $i$-th friend doesn't know whom he wants to give the gift to or $1 \le f_i \le n$ if the $i$-th friend wants to give the gift to the friend $f_i$.
You want to fill in the unknown values ($f_i = 0$) in such a way that each friend gives exactly one gift and receives exactly one gift and there is no friend who gives the gift to himself. It is guaranteed that the initial information isn't contradictory.
If there are several answers, you can print any.
-----Input-----
The first line of the input contains one integer $n$ ($2 \le n \le 2 \cdot 10^5$) — the number of friends.
The second line of the input contains $n$ integers $f_1, f_2, \dots, f_n$ ($0 \le f_i \le n$, $f_i \ne i$, all $f_i \ne 0$ are distinct), where $f_i$ is the either $f_i = 0$ if the $i$-th friend doesn't know whom he wants to give the gift to or $1 \le f_i \le n$ if the $i$-th friend wants to give the gift to the friend $f_i$. It is also guaranteed that there is at least two values $f_i = 0$.
-----Output-----
Print $n$ integers $nf_1, nf_2, \dots, nf_n$, where $nf_i$ should be equal to $f_i$ if $f_i \ne 0$ or the number of friend whom the $i$-th friend wants to give the gift to. All values $nf_i$ should be distinct, $nf_i$ cannot be equal to $i$. Each friend gives exactly one gift and receives exactly one gift and there is no friend who gives the gift to himself.
If there are several answers, you can print any.
-----Examples-----
Input
5
5 0 0 2 4
Output
5 3 1 2 4
Input
7
7 0 0 1 4 0 6
Output
7 3 2 1 4 5 6
Input
7
7 4 0 3 0 5 1
Output
7 4 2 3 6 5 1
Input
5
2 1 0 0 0
Output
2 1 4 5 3
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())
F=list(map(int,input().split()))
USE=[0]*(n+1)
B=[]
for i in range(n):
USE[F[i]]=1
if F[i]==0:
B.append(i+1)
A=[]
for i in range(1,n+1):
if USE[i]==0:
A.append(i)
for i in range(len(A)-1):
if A[i]==B[i]:
A[i],A[i+1]=A[i+1],A[i]
if A[-1]==B[-1]:
A[-1],A[-2]=A[-2],A[-1]
ind=0
for i in range(n):
if F[i]==0:
F[i]=A[ind]
ind+=1
print(*F)
``` | vfc_24735 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1283/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n5 0 0 2 4\n",
"output": "5 3 1 2 4 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "7\n7 0 0 1 4 0 6\n",
"output": "7 3 2 1 4 5 6 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "7\n7 4 0 3 0 5 1\n",
"output": "7 4 2 3 6 5 1 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n2 1 0 0 0\n",
"output": "2 1 4 5 3 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n0 0\n",
"output": "2 1 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4008 | Solve the following coding problem using the programming language python:
You are given an array $a$ consisting of $n$ integer numbers.
You have to color this array in $k$ colors in such a way that: Each element of the array should be colored in some color; For each $i$ from $1$ to $k$ there should be at least one element colored in the $i$-th color in the array; For each $i$ from $1$ to $k$ all elements colored in the $i$-th color should be distinct.
Obviously, such coloring might be impossible. In this case, print "NO". Otherwise print "YES" and any coloring (i.e. numbers $c_1, c_2, \dots c_n$, where $1 \le c_i \le k$ and $c_i$ is the color of the $i$-th element of the given array) satisfying the conditions above. If there are multiple answers, you can print any.
-----Input-----
The first line of the input contains two integers $n$ and $k$ ($1 \le k \le n \le 5000$) — the length of the array $a$ and the number of colors, respectively.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 5000$) — elements of the array $a$.
-----Output-----
If there is no answer, print "NO". Otherwise print "YES" and any coloring (i.e. numbers $c_1, c_2, \dots c_n$, where $1 \le c_i \le k$ and $c_i$ is the color of the $i$-th element of the given array) satisfying the conditions described in the problem statement. If there are multiple answers, you can print any.
-----Examples-----
Input
4 2
1 2 2 3
Output
YES
1 1 2 2
Input
5 2
3 2 1 2 3
Output
YES
2 1 1 2 1
Input
5 2
2 1 1 2 1
Output
NO
-----Note-----
In the first example the answer $2~ 1~ 2~ 1$ is also acceptable.
In the second example the answer $1~ 1~ 1~ 2~ 2$ is also acceptable.
There exist other acceptable answers for both examples.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def main():
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
colors = [[] for _ in range(k)]
seen = [0 for _ in range(5003)]
ans = [-1 for _ in range(n)]
for i, x in enumerate(a):
if seen[x] >= k:
print('NO')
return
ans[i] = seen[x]
colors[ans[i]].append(i)
seen[x] += 1
p = 0
for i in range(k):
if not colors[i]:
while p < i and len(colors[p]) == 1:
p += 1
if p == i:
print('NO')
return
colors[i].append(colors[p].pop())
ans[colors[i][-1]] = i
print('YES')
print(' '.join(str(x + 1) for x in ans))
main()
``` | vfc_24739 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1102/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 2\n1 2 2 3\n",
"output": "YES\n1 2 1 2 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 2\n3 2 1 2 3\n",
"output": "YES\n2 2 1 1 1 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 2\n2 1 1 2 1\n",
"output": "NO\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4009 | Solve the following coding problem using the programming language python:
You are given a huge decimal number consisting of $n$ digits. It is guaranteed that this number has no leading zeros. Each digit of this number is either 0 or 1.
You may perform several (possibly zero) operations with this number. During each operation you are allowed to change any digit of your number; you may change 0 to 1 or 1 to 0. It is possible that after some operation you can obtain a number with leading zeroes, but it does not matter for this problem.
You are also given two integers $0 \le y < x < n$. Your task is to calculate the minimum number of operations you should perform to obtain the number that has remainder $10^y$ modulo $10^x$. In other words, the obtained number should have remainder $10^y$ when divided by $10^x$.
-----Input-----
The first line of the input contains three integers $n, x, y$ ($0 \le y < x < n \le 2 \cdot 10^5$) — the length of the number and the integers $x$ and $y$, respectively.
The second line of the input contains one decimal number consisting of $n$ digits, each digit of this number is either 0 or 1. It is guaranteed that the first digit of the number is 1.
-----Output-----
Print one integer — the minimum number of operations you should perform to obtain the number having remainder $10^y$ modulo $10^x$. In other words, the obtained number should have remainder $10^y$ when divided by $10^x$.
-----Examples-----
Input
11 5 2
11010100101
Output
1
Input
11 5 1
11010100101
Output
3
-----Note-----
In the first example the number will be $11010100100$ after performing one operation. It has remainder $100$ modulo $100000$.
In the second example the number will be $11010100010$ after performing three operations. It has remainder $10$ modulo $100000$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n, x, y = map(int, input().split())
s = input()[-x:]
res = s.count('1')
if s[-y - 1] == '1': res -= 1
else: res += 1
# print(s)
print(res)
``` | vfc_24743 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1165/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "11 5 2\n11010100101\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "11 5 1\n11010100101\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 1 0\n10\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "11 5 2\n11010000101\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4012 | Solve the following coding problem using the programming language python:
You are given three integers $a \le b \le c$.
In one move, you can add $+1$ or $-1$ to any of these integers (i.e. increase or decrease any number by one). You can perform such operation any (possibly, zero) number of times, you can even perform this operation several times with one number. Note that you cannot make non-positive numbers using such operations.
You have to perform the minimum number of such operations in order to obtain three integers $A \le B \le C$ such that $B$ is divisible by $A$ and $C$ is divisible by $B$.
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 $t$ lines describe test cases. Each test case is given on a separate line as three space-separated integers $a, b$ and $c$ ($1 \le a \le b \le c \le 10^4$).
-----Output-----
For each test case, print the answer. In the first line print $res$ — the minimum number of operations you have to perform to obtain three integers $A \le B \le C$ such that $B$ is divisible by $A$ and $C$ is divisible by $B$. On the second line print any suitable triple $A, B$ and $C$.
-----Example-----
Input
8
1 2 3
123 321 456
5 10 15
15 18 21
100 100 101
1 22 29
3 19 38
6 30 46
Output
1
1 1 3
102
114 228 456
4
4 8 16
6
18 18 18
1
100 100 100
7
1 22 22
2
1 19 38
8
6 24 48
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
mii = 3*10**4
factors = [set() for _ in range(mii + 1)]
factors[1] = set([1])
for k in range(2, mii + 1):
for p in range(2, mii + 1):
if k % p == 0:
factors[k] = set(ole*p for ole in factors[k//p]) | factors[k//p]
break
elif p * p > k:
factors[k] = set([1, k])
break
# print(factors[:20])
t = int(input())
for _ in range(t):
a, b, c = [int(x) for x in input().split()]
best_score = 10**15
best_trip = a, b, c
for k in range(1, mii + 1):
this_b = k
if c % this_b < this_b - (c % this_b):
this_c = this_b * (c // this_b)
else:
this_c = this_b * (c // this_b + 1)
this_c = max(this_c, this_b)
this_a = -1
loss_a = 10**15
for cur_a in factors[this_b]:
if abs(a - cur_a) < loss_a:
this_a = cur_a
loss_a = abs(a - cur_a)
cur_score = abs(a - this_a) + abs(b - this_b) + abs(c - this_c)
if cur_score < best_score:
best_score = cur_score
best_trip = this_a, this_b, this_c
print(best_score)
print(*best_trip)
``` | vfc_24755 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1311/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "8\n1 2 3\n123 321 456\n5 10 15\n15 18 21\n100 100 101\n1 22 29\n3 19 38\n6 30 46\n",
"output": "1\n1 1 3\n102\n114 228 456\n4\n4 8 16\n6\n18 18 18\n1\n100 100 100\n7\n1 22 22\n2\n1 19 38\n8\n6 24 48\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n137 10000 10000\n",
"output": "2\n137 10001 10001\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1 137 10000\n",
"output": "1\n1 137 10001\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n73 10000 10000\n",
"output": "2\n73 10001 10001\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1667 3334 10000\n",
"output": "2\n1667 3334 10002\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n256 4096 10000\n",
"output": "779\n257 3341 10023\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4013 | Solve the following coding problem using the programming language python:
You are given an array $a$ consisting of $n$ integer numbers.
Let instability of the array be the following value: $\max\limits_{i = 1}^{n} a_i - \min\limits_{i = 1}^{n} a_i$.
You have to remove exactly one element from this array to minimize instability of the resulting $(n-1)$-elements array. Your task is to calculate the minimum possible instability.
-----Input-----
The first line of the input contains one integer $n$ ($2 \le n \le 10^5$) — the number of elements in the array $a$.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^5$) — elements of the array $a$.
-----Output-----
Print one integer — the minimum possible instability of the array if you have to remove exactly one element from the array $a$.
-----Examples-----
Input
4
1 3 3 7
Output
2
Input
2
1 100000
Output
0
-----Note-----
In the first example you can remove $7$ then instability of the remaining array will be $3 - 1 = 2$.
In the second example you can remove either $1$ or $100000$ then instability of the remaining array will be $100000 - 100000 = 0$ and $1 - 1 = 0$ correspondingly.
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()
print(min(a[-1] - a[1], a[-2] - a[0]))
``` | vfc_24759 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1095/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n1 3 3 7\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1 100000\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n3 1 4 4 2\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n1 10 11\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "60\n36 91 2 38 37 49 48 11 59 67 53 56 35 60 87 59 60 16 73 34 15 4 57 40 38 44 4 80 63 26 94 99 68 47 88 4 96 36 15 54 54 19 9 88 78 47 99 90 63 23 23 77 79 31 68 68 75 71 100 37\n",
"output": "96\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n1 2 4\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4014 | Solve the following coding problem using the programming language python:
Petya studies at university. The current academic year finishes with $n$ special days. Petya needs to pass $m$ exams in those special days. The special days in this problem are numbered from $1$ to $n$.
There are three values about each exam: $s_i$ — the day, when questions for the $i$-th exam will be published, $d_i$ — the day of the $i$-th exam ($s_i < d_i$), $c_i$ — number of days Petya needs to prepare for the $i$-th exam. For the $i$-th exam Petya should prepare in days between $s_i$ and $d_i-1$, inclusive.
There are three types of activities for Petya in each day: to spend a day doing nothing (taking a rest), to spend a day passing exactly one exam or to spend a day preparing for exactly one exam. So he can't pass/prepare for multiple exams in a day. He can't mix his activities in a day. If he is preparing for the $i$-th exam in day $j$, then $s_i \le j < d_i$.
It is allowed to have breaks in a preparation to an exam and to alternate preparations for different exams in consecutive days. So preparation for an exam is not required to be done in consecutive days.
Find the schedule for Petya to prepare for all exams and pass them, or report that it is impossible.
-----Input-----
The first line contains two integers $n$ and $m$ $(2 \le n \le 100, 1 \le m \le n)$ — the number of days and the number of exams.
Each of the following $m$ lines contains three integers $s_i$, $d_i$, $c_i$ $(1 \le s_i < d_i \le n, 1 \le c_i \le n)$ — the day, when questions for the $i$-th exam will be given, the day of the $i$-th exam, number of days Petya needs to prepare for the $i$-th exam.
Guaranteed, that all the exams will be in different days. Questions for different exams can be given in the same day. It is possible that, in the day of some exam, the questions for other exams are given.
-----Output-----
If Petya can not prepare and pass all the exams, print -1. In case of positive answer, print $n$ integers, where the $j$-th number is: $(m + 1)$, if the $j$-th day is a day of some exam (recall that in each day no more than one exam is conducted), zero, if in the $j$-th day Petya will have a rest, $i$ ($1 \le i \le m$), if Petya will prepare for the $i$-th exam in the day $j$ (the total number of days Petya prepares for each exam should be strictly equal to the number of days needed to prepare for it).
Assume that the exams are numbered in order of appearing in the input, starting from $1$.
If there are multiple schedules, print any of them.
-----Examples-----
Input
5 2
1 3 1
1 5 1
Output
1 2 3 0 3
Input
3 2
1 3 1
1 2 1
Output
-1
Input
10 3
4 7 2
1 10 3
8 9 1
Output
2 2 2 1 1 0 4 3 4 4
-----Note-----
In the first example Petya can, for example, prepare for exam $1$ in the first day, prepare for exam $2$ in the second day, pass exam $1$ in the third day, relax in the fourth day, and pass exam $2$ in the fifth day. So, he can prepare and pass all exams.
In the second example, there are three days and two exams. So, Petya can prepare in only one day (because in two other days he should pass exams). Then Petya can not prepare and pass all exams.
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 b[i]
n,m=map(int,input().split())
a=[0]*m
b=[0]*m
c=[0]*m
e=[]
ans=[0]*n
for i in range(m):
a[i],b[i],c[i]=map(int,input().split())
ans[b[i]-1]=m+1
e.append(i)
e.sort(key=ke)
for i in range(m):
k=0
for j in range(a[e[i]]-1,b[e[i]]-1):
if ans[j]==0:
ans[j]=e[i]+1
k+=1
if k==c[e[i]]:
break
if k!=c[e[i]]:
print(-1)
return
for i in ans:
print(i,end=' ')
``` | vfc_24763 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/978/G",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5 2\n1 3 1\n1 5 1\n",
"output": "1 2 3 0 3 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 2\n1 3 1\n1 2 1\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10 3\n4 7 2\n1 10 3\n8 9 1\n",
"output": "2 2 2 1 1 0 4 3 4 4 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 1\n1 2 1\n",
"output": "1 2 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 1\n1 2 2\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 1\n1 3 2\n",
"output": "1 1 2 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4015 | Solve the following coding problem using the programming language python:
Polycarp plays "Game 23". Initially he has a number $n$ and his goal is to transform it to $m$. In one move, he can multiply $n$ by $2$ or multiply $n$ by $3$. He can perform any number of moves.
Print the number of moves needed to transform $n$ to $m$. Print -1 if it is impossible to do so.
It is easy to prove that any way to transform $n$ to $m$ contains the same number of moves (i.e. number of moves doesn't depend on the way of transformation).
-----Input-----
The only line of the input contains two integers $n$ and $m$ ($1 \le n \le m \le 5\cdot10^8$).
-----Output-----
Print the number of moves to transform $n$ to $m$, or -1 if there is no solution.
-----Examples-----
Input
120 51840
Output
7
Input
42 42
Output
0
Input
48 72
Output
-1
-----Note-----
In the first example, the possible sequence of moves is: $120 \rightarrow 240 \rightarrow 720 \rightarrow 1440 \rightarrow 4320 \rightarrow 12960 \rightarrow 25920 \rightarrow 51840.$ The are $7$ steps in total.
In the second example, no moves are needed. Thus, the answer is $0$.
In the third example, it is impossible to transform $48$ to $72$.
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())
if m % n == 0:
k = m // n
res = 0
while k % 2 == 0:
k //= 2
res += 1
while k % 3 == 0:
k //= 3
res += 1
if k > 1:
print(-1)
else:
print(res)
else:
print(-1)
``` | vfc_24767 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1141/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "120 51840\n",
"output": "7\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4016 | Solve the following coding problem using the programming language python:
You are given a string $t$ consisting of $n$ lowercase Latin letters and an integer number $k$.
Let's define a substring of some string $s$ with indices from $l$ to $r$ as $s[l \dots r]$.
Your task is to construct such string $s$ of minimum possible length that there are exactly $k$ positions $i$ such that $s[i \dots i + n - 1] = t$. In other words, your task is to construct such string $s$ of minimum possible length that there are exactly $k$ substrings of $s$ equal to $t$.
It is guaranteed that the answer is always unique.
-----Input-----
The first line of the input contains two integers $n$ and $k$ ($1 \le n, k \le 50$) — the length of the string $t$ and the number of substrings.
The second line of the input contains the string $t$ consisting of exactly $n$ lowercase Latin letters.
-----Output-----
Print such string $s$ of minimum possible length that there are exactly $k$ substrings of $s$ equal to $t$.
It is guaranteed that the answer is always unique.
-----Examples-----
Input
3 4
aba
Output
ababababa
Input
3 2
cat
Output
catcat
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
'''input
3 4
aba
'''
n, k = map(int, input().split())
t = input()
for i in range(1, n):
if t[i:] == t[:n-i]:
print(t[:i] * k + t[i:])
break
else:
print(t * k)
``` | vfc_24771 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1029/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 4\naba\n",
"output": "ababababa\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4017 | Solve the following coding problem using the programming language python:
Let's call an array good if there is an element in the array that equals to the sum of all other elements. For example, the array $a=[1, 3, 3, 7]$ is good because there is the element $a_4=7$ which equals to the sum $1 + 3 + 3$.
You are given an array $a$ consisting of $n$ integers. Your task is to print all indices $j$ of this array such that after removing the $j$-th element from the array it will be good (let's call such indices nice).
For example, if $a=[8, 3, 5, 2]$, the nice indices are $1$ and $4$: if you remove $a_1$, the array will look like $[3, 5, 2]$ and it is good; if you remove $a_4$, the array will look like $[8, 3, 5]$ and it is good.
You have to consider all removals independently, i. e. remove the element, check if the resulting array is good, and return the element into the array.
-----Input-----
The first line of the input contains one integer $n$ ($2 \le n \le 2 \cdot 10^5$) — the number of elements in the array $a$.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^6$) — elements of the array $a$.
-----Output-----
In the first line print one integer $k$ — the number of indices $j$ of the array $a$ such that after removing the $j$-th element from the array it will be good (i.e. print the number of the nice indices).
In the second line print $k$ distinct integers $j_1, j_2, \dots, j_k$ in any order — nice indices of the array $a$.
If there are no such indices in the array $a$, just print $0$ in the first line and leave the second line empty or do not print it at all.
-----Examples-----
Input
5
2 5 1 2 2
Output
3
4 1 5
Input
4
8 3 5 2
Output
2
1 4
Input
5
2 1 2 4 3
Output
0
-----Note-----
In the first example you can remove any element with the value $2$ so the array will look like $[5, 1, 2, 2]$. The sum of this array is $10$ and there is an element equals to the sum of remaining elements ($5 = 1 + 2 + 2$).
In the second example you can remove $8$ so the array will look like $[3, 5, 2]$. The sum of this array is $10$ and there is an element equals to the sum of remaining elements ($5 = 3 + 2$). You can also remove $2$ so the array will look like $[8, 3, 5]$. The sum of this array is $16$ and there is an element equals to the sum of remaining elements ($8 = 3 + 5$).
In the third example you cannot make the given array good by removing exactly one element.
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()))
c = [ 0 for i in range(1000001) ]
s = sum(a)
ans = []
for i in a: c[i] += 1
for i in range(n):
s -= a[i]
c[a[i]] -= 1
if s % 2 == 0 and s // 2 <= 1000000 and c[s // 2] > 0:
ans.append(i)
s += a[i]
c[a[i]] += 1
print(len(ans))
for i in ans:
print(i + 1, end=' ')
``` | vfc_24775 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1077/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n2 5 1 2 2\n",
"output": "3\n1 4 5 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4018 | Solve the following coding problem using the programming language python:
The only difference between the easy and the hard versions is constraints.
A subsequence is a string that can be derived from another string by deleting some or no symbols without changing the order of the remaining symbols. Characters to be deleted are not required to go successively, there can be any gaps between them. For example, for the string "abaca" the following strings are subsequences: "abaca", "aba", "aaa", "a" and "" (empty string). But the following strings are not subsequences: "aabaca", "cb" and "bcaa".
You are given a string $s$ consisting of $n$ lowercase Latin letters.
In one move you can take any subsequence $t$ of the given string and add it to the set $S$. The set $S$ can't contain duplicates. This move costs $n - |t|$, where $|t|$ is the length of the added subsequence (i.e. the price equals to the number of the deleted characters).
Your task is to find out the minimum possible total cost to obtain a set $S$ of size $k$ or report that it is impossible to do so.
-----Input-----
The first line of the input contains two integers $n$ and $k$ ($1 \le n \le 100, 1 \le k \le 10^{12}$) — the length of the string and the size of the set, correspondingly.
The second line of the input contains a string $s$ consisting of $n$ lowercase Latin letters.
-----Output-----
Print one integer — if it is impossible to obtain the set $S$ of size $k$, print -1. Otherwise, print the minimum possible total cost to do it.
-----Examples-----
Input
4 5
asdf
Output
4
Input
5 6
aaaaa
Output
15
Input
5 7
aaaaa
Output
-1
Input
10 100
ajihiushda
Output
233
-----Note-----
In the first example we can generate $S$ = { "asdf", "asd", "adf", "asf", "sdf" }. The cost of the first element in $S$ is $0$ and the cost of the others is $1$. So the total cost of $S$ is $4$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def sol(a,k):
n=len(a)
if(k==0):return 1
if(k==1):
v=set()
for x in a:
v.add(x)
return len(v)
if(n<k or n<1 or k<1):
return 0
if(n==k):
return 1
sz=max(3000,n)
v1=[0]*sz
v2=[0]*sz
v3=[0]*sz
v2[n-1]=1
v3[a[n-1]-1]=1
for i in range(n-2,-1,-1):
if(i<0):break
v2[i]=v2[i+1]
if(v3[a[i]-1]==0):
v2[i]+=1
v3[a[i]-1]=1
for j in range(1,k):
v3=[0]*sz
v1[n-1]=0
for i in range(n-2,-1,-1):
v1[i]=v1[i+1]
v1[i]=v1[i]+v2[i+1]
v1[i] = v1[i] - v3[a[i] - 1]
v3[a[i] - 1] = v2[i + 1]
v2=v1.copy()
return v1[0]
n,k=list(map(int,input().split()))
s=input()
ar=[]
for x in s:
ar.append(ord(x))
ans=0
cur=n
while cur>=0:
mx=min(k,sol(ar,cur))
k-=mx
ans+=(n-cur)*mx
cur-=1
if(k!=0):
print(-1)
else:
print(ans)
``` | vfc_24779 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1183/H",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 5\nasdf\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 6\naaaaa\n",
"output": "15\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 7\naaaaa\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10 100\najihiushda\n",
"output": "233\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 2\nu\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4019 | 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 degree of the first vertex (vertex with label $1$ on it) is equal to $D$ (or say that there are no such spanning trees). Recall that the degree of a vertex is the number of edges incident to it.
-----Input-----
The first line contains three integers $n$, $m$ and $D$ ($2 \le n \le 2 \cdot 10^5$, $n - 1 \le m \le min(2 \cdot 10^5, \frac{n(n-1)}{2}), 1 \le D < n$) — the number of vertices, the number of edges and required degree of the first vertex, 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-----
If there is no spanning tree satisfying the condition from the problem statement, print "NO" in the first line.
Otherwise print "YES" in the first line and then print $n-1$ lines describing the edges of a spanning tree such that the degree of the first vertex (vertex with label $1$ on it) is equal to $D$. 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
4 5 1
1 2
1 3
1 4
2 3
3 4
Output
YES
2 1
2 3
3 4
Input
4 5 3
1 2
1 3
1 4
2 3
3 4
Output
YES
1 2
1 3
4 1
Input
4 4 3
1 2
1 4
2 3
3 4
Output
NO
-----Note-----
The picture corresponding to the first and second examples: [Image]
The picture corresponding to the third example: [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
n,m,D=list(map(int,input().split()))
E=[list(map(int,input().split())) for i in range(m)]
EDGELIST=[[] for i in range(n+1)]
for x,y in E:
EDGELIST[x].append(y)
EDGELIST[y].append(x)
Group=[i for i in range(n+1)]
def find(x):
while Group[x] != x:
x=Group[x]
return x
def Union(x,y):
if find(x) != find(y):
Group[find(y)]=Group[find(x)]=min(find(y),find(x))
ONE=EDGELIST[1]
for x,y in E:
if x==1 or y==1:
continue
Union(x,y)
ONEU=[find(e) for e in ONE]
if len(set(ONEU))>D or D>len(ONE):
print("NO")
return
else:
print("YES")
USED=set()
ANS=[]
from collections import deque
QUE=deque()
check=[0]*(n+1)
check[1]=1
for j in range(len(ONE)):
if find(ONE[j]) in USED:
continue
else:
ANS.append([1,ONE[j]])
QUE.append(ONE[j])
USED.add(find(ONE[j]))
check[ONE[j]]=1
D-=1
j=0
for i in range(D):
while check[ONE[j]]==1:
j+=1
ANS.append([1,ONE[j]])
QUE.append(ONE[j])
check[ONE[j]]=1
while QUE:
x=QUE.popleft()
check[x]=1
for to in EDGELIST[x]:
if check[to]==0:
ANS.append([x,to])
QUE.append(to)
check[to]=1
#print(ANS)
for x,y in ANS:
print(x,y)
``` | vfc_24783 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1133/F2",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 5 1\n1 2\n1 3\n1 4\n2 3\n3 4\n",
"output": "YES\n2 3\n3 4\n2 1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 5 3\n1 2\n1 3\n1 4\n2 3\n3 4\n",
"output": "YES\n4 1\n2 1\n1 3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 4 3\n1 2\n1 4\n2 3\n3 4\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 1 1\n1 2\n",
"output": "YES\n1 2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 2 1\n1 2\n3 1\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 3 1\n2 3\n1 2\n3 1\n",
"output": "YES\n1 2\n3 2\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4020 | Solve the following coding problem using the programming language python:
Polycarp is going to participate in the contest. It starts at $h_1:m_1$ and ends at $h_2:m_2$. It is guaranteed that the contest lasts an even number of minutes (i.e. $m_1 \% 2 = m_2 \% 2$, where $x \% y$ is $x$ modulo $y$). It is also guaranteed that the entire contest is held during a single day. And finally it is guaranteed that the contest lasts at least two minutes.
Polycarp wants to know the time of the midpoint of the contest. For example, if the contest lasts from $10:00$ to $11:00$ then the answer is $10:30$, if the contest lasts from $11:10$ to $11:12$ then the answer is $11:11$.
-----Input-----
The first line of the input contains two integers $h_1$ and $m_1$ in the format hh:mm.
The second line of the input contains two integers $h_2$ and $m_2$ in the same format (hh:mm).
It is guaranteed that $0 \le h_1, h_2 \le 23$ and $0 \le m_1, m_2 \le 59$.
It is guaranteed that the contest lasts an even number of minutes (i.e. $m_1 \% 2 = m_2 \% 2$, where $x \% y$ is $x$ modulo $y$). It is also guaranteed that the entire contest is held during a single day. And finally it is guaranteed that the contest lasts at least two minutes.
-----Output-----
Print two integers $h_3$ and $m_3$ ($0 \le h_3 \le 23, 0 \le m_3 \le 59$) corresponding to the midpoint of the contest in the format hh:mm. Print each number as exactly two digits (prepend a number with leading zero if needed), separate them with ':'.
-----Examples-----
Input
10:00
11:00
Output
10:30
Input
11:10
11:12
Output
11:11
Input
01:02
03:02
Output
02:02
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
h1, m1 = list(map(int, input().split(':')))
h2, m2 = list(map(int, input().split(':')))
z = h1 * 60 + m1 + h2 * 60 + m2
z //= 2
print(str(z // 60 // 10) + str(z // 60 % 10) + ':' + str(z % 60 // 10) + str(z % 60 % 10))
``` | vfc_24787 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1133/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "10:00\n11:00\n",
"output": "10:30\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "11:10\n11:12\n",
"output": "11:11\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "01:02\n03:02\n",
"output": "02:02\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "00:00\n23:58\n",
"output": "11:59\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "00:01\n23:59\n",
"output": "12:00\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4021 | Solve the following coding problem using the programming language python:
-----Input-----
The input contains a single integer a (1 ≤ a ≤ 64).
-----Output-----
Output a single integer.
-----Examples-----
Input
2
Output
1
Input
4
Output
2
Input
27
Output
5
Input
42
Output
6
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
"""
Codeforces April Fools Contest 2014 Problem F
Author : chaotic_iak
Language: Python 3.3.4
"""
class InputHandlerObject(object):
inputs = []
def getInput(self, n = 0):
res = ""
inputs = self.inputs
if not inputs: inputs.extend(input().split(" "))
if n == 0:
res = inputs[:]
inputs[:] = []
while n > len(inputs):
inputs.extend(input().split(" "))
if n > 0:
res = inputs[:n]
inputs[:n] = []
return res
InputHandler = InputHandlerObject()
g = InputHandler.getInput
############################## SOLUTION ##############################
x = int(input())
a = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51, 1, 2, 1, 14, 1, 2, 2, 14, 1, 6, 1, 4, 2, 2, 1, 52, 2, 5, 1, 5, 1, 15, 2, 13, 2, 2, 1, 13, 1, 2, 4, 267]
print(a[x-1])
``` | vfc_24791 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/409/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "27\n",
"output": "5\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "42\n",
"output": "6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4022 | Solve the following coding problem using the programming language python:
You are given $n$ segments on a number line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
The intersection of a sequence of segments is such a maximal set of points (not necesserily having integer coordinates) that each point lies within every segment from the sequence. If the resulting set isn't empty, then it always forms some continuous segment. The length of the intersection is the length of the resulting segment or $0$ in case the intersection is an empty set.
For example, the intersection of segments $[1;5]$ and $[3;10]$ is $[3;5]$ (length $2$), the intersection of segments $[1;5]$ and $[5;7]$ is $[5;5]$ (length $0$) and the intersection of segments $[1;5]$ and $[6;6]$ is an empty set (length $0$).
Your task is to remove exactly one segment from the given sequence in such a way that the intersection of the remaining $(n - 1)$ segments has the maximal possible length.
-----Input-----
The first line contains a single integer $n$ ($2 \le n \le 3 \cdot 10^5$) — the number of segments in the sequence.
Each of the next $n$ lines contains two integers $l_i$ and $r_i$ ($0 \le l_i \le r_i \le 10^9$) — the description of the $i$-th segment.
-----Output-----
Print a single integer — the maximal possible length of the intersection of $(n - 1)$ remaining segments after you remove exactly one segment from the sequence.
-----Examples-----
Input
4
1 3
2 6
0 4
3 3
Output
1
Input
5
2 6
1 3
0 4
1 20
0 4
Output
2
Input
3
4 5
1 2
9 20
Output
0
Input
2
3 10
1 5
Output
7
-----Note-----
In the first example you should remove the segment $[3;3]$, the intersection will become $[2;3]$ (length $1$). Removing any other segment will result in the intersection $[3;3]$ (length $0$).
In the second example you should remove the segment $[1;3]$ or segment $[2;6]$, the intersection will become $[2;4]$ (length $2$) or $[1;3]$ (length $2$), respectively. Removing any other segment will result in the intersection $[2;3]$ (length $1$).
In the third example the intersection will become an empty set no matter the segment you remove.
In the fourth example you will get the intersection $[3;10]$ (length $7$) if you remove the segment $[1;5]$ or the intersection $[1;5]$ (length $4$) if you remove the segment $[3;10]$.
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 = []
for i in range(n):
inp = input().split()
a.append((int(inp[0]),int(inp[1])))
#End of Input Part
first = []
second = []
for i in range(n):
first.append(a[i][0])
second.append(a[i][1])
# Sort Them
first.sort(reverse = True)
second.sort()
bestAnswer = 0
for i in range(n):
l = first[0]
r = second[0]
if(l==a[i][0]):
l = first[1]
if(r==a[i][1]):
r = second[1]
curLength = r-l
bestAnswer = max(bestAnswer,curLength)
#Print Answer
print(bestAnswer)
``` | vfc_24795 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1029/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n1 3\n2 6\n0 4\n3 3\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n2 6\n1 3\n0 4\n1 20\n0 4\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n4 5\n1 2\n9 20\n",
"output": "0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4023 | Solve the following coding problem using the programming language python:
Vova's family is building the Great Vova Wall (named by Vova himself). Vova's parents, grandparents, grand-grandparents contributed to it. Now it's totally up to Vova to put the finishing touches.
The current state of the wall can be respresented by a sequence $a$ of $n$ integers, with $a_i$ being the height of the $i$-th part of the wall.
Vova can only use $2 \times 1$ bricks to put in the wall (he has infinite supply of them, however).
Vova can put bricks only horizontally on the neighbouring parts of the wall of equal height. It means that if for some $i$ the current height of part $i$ is the same as for part $i + 1$, then Vova can put a brick there and thus increase both heights by 1. Obviously, Vova can't put bricks in such a way that its parts turn out to be off the borders (to the left of part $1$ of the wall or to the right of part $n$ of it).
Note that Vova can't put bricks vertically.
Vova is a perfectionist, so he considers the wall completed when: all parts of the wall has the same height; the wall has no empty spaces inside it.
Can Vova complete the wall using any amount of bricks (possibly zero)?
-----Input-----
The first line contains a single integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the number of parts in the wall.
The second line contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^9$) — the initial heights of the parts of the wall.
-----Output-----
Print "YES" if Vova can complete the wall using any amount of bricks (possibly zero).
Print "NO" otherwise.
-----Examples-----
Input
5
2 1 1 2 5
Output
YES
Input
3
4 5 3
Output
NO
Input
2
10 10
Output
YES
-----Note-----
In the first example Vova can put a brick on parts 2 and 3 to make the wall $[2, 2, 2, 2, 5]$ and then put 3 bricks on parts 1 and 2 and 3 bricks on parts 3 and 4 to make it $[5, 5, 5, 5, 5]$.
In the second example Vova can put no bricks in the wall.
In the third example the wall is already complete.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
#
import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)
def getIntList():
return list(map(int, input().split()))
try :
#raise ModuleNotFoundError
import numpy
def dprint(*args, **kwargs):
#print(*args, **kwargs, file=sys.stderr)
# in python 3.4 **kwargs is invalid???
print(*args, file=sys.stderr)
dprint('debug mode')
except Exception:
def dprint(*args, **kwargs):
pass
inId = 0
outId = 0
if inId>0:
dprint('use input', inId)
sys.stdin = open('input'+ str(inId) + '.txt', 'r') #标准输出重定向至文件
if outId>0:
dprint('use output', outId)
sys.stdout = open('stdout'+ str(outId) + '.txt', 'w') #标准输出重定向至文件
atexit.register(lambda :sys.stdout.close()) #idle 中不会执行 atexit
N, = getIntList()
#print(N)
za = getIntList()
mh = max(za)
za.append(mh)
duo = [(mh,0)]
for i in range(N+1):
h = za[i]
while duo:
if i%2 != duo[-1][1]%2:
dprint(i )
print('NO')
return
if h >= duo[-1][0]:
lh = duo[-1][0]
duo.pop()
if h== lh:
break
else:
break
duo.append( (h,i+1))
#dprint(duo)
print('YES')
``` | vfc_24799 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1092/D2",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n2 1 1 2 5\n",
"output": "YES\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4024 | Solve the following coding problem using the programming language python:
The only difference between the easy and the hard versions is constraints.
A subsequence is a string that can be derived from another string by deleting some or no symbols without changing the order of the remaining symbols. Characters to be deleted are not required to go successively, there can be any gaps between them. For example, for the string "abaca" the following strings are subsequences: "abaca", "aba", "aaa", "a" and "" (empty string). But the following strings are not subsequences: "aabaca", "cb" and "bcaa".
You are given a string $s$ consisting of $n$ lowercase Latin letters.
In one move you can take any subsequence $t$ of the given string and add it to the set $S$. The set $S$ can't contain duplicates. This move costs $n - |t|$, where $|t|$ is the length of the added subsequence (i.e. the price equals to the number of the deleted characters).
Your task is to find out the minimum possible total cost to obtain a set $S$ of size $k$ or report that it is impossible to do so.
-----Input-----
The first line of the input contains two integers $n$ and $k$ ($1 \le n, k \le 100$) — the length of the string and the size of the set, correspondingly.
The second line of the input contains a string $s$ consisting of $n$ lowercase Latin letters.
-----Output-----
Print one integer — if it is impossible to obtain the set $S$ of size $k$, print -1. Otherwise, print the minimum possible total cost to do it.
-----Examples-----
Input
4 5
asdf
Output
4
Input
5 6
aaaaa
Output
15
Input
5 7
aaaaa
Output
-1
Input
10 100
ajihiushda
Output
233
-----Note-----
In the first example we can generate $S$ = { "asdf", "asd", "adf", "asf", "sdf" }. The cost of the first element in $S$ is $0$ and the cost of the others is $1$. So the total cost of $S$ is $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 itertools
inputs = sys.stdin.read().split()
len_string = int(inputs[0])
desired_size = int(inputs[1])
string = inputs[2]
size = 0
cost = 0
cur_set = set()
cur_set.add(string)
for i in range(len_string, -1, -1):
cur_size = len(cur_set)
if size+cur_size >= desired_size:
cost += (desired_size-size)*(len_string-i)
size = desired_size
break
cost += cur_size*(len_string-i)
size += cur_size
new_set = set()
for substr in cur_set:
for i in range(len(substr)):
new_set.add(substr[:i]+substr[(i+1):])
cur_set = new_set
if size >= desired_size: sys.stdout.write(str(cost)+"\n")
else: sys.stdout.write("-1\n")
``` | vfc_24803 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1183/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 5\nasdf\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 6\naaaaa\n",
"output": "15\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 7\naaaaa\n",
"output": "-1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4025 | Solve the following coding problem using the programming language python:
Polycarp has a cat and his cat is a real gourmet! Dependent on a day of the week he eats certain type of food: on Mondays, Thursdays and Sundays he eats fish food; on Tuesdays and Saturdays he eats rabbit stew; on other days of week he eats chicken stake.
Polycarp plans to go on a trip and already packed his backpack. His backpack contains: $a$ daily rations of fish food; $b$ daily rations of rabbit stew; $c$ daily rations of chicken stakes.
Polycarp has to choose such day of the week to start his trip that his cat can eat without additional food purchases as long as possible. Print the maximum number of days the cat can eat in a trip without additional food purchases, if Polycarp chooses the day of the week to start his trip optimally.
-----Input-----
The first line of the input contains three positive integers $a$, $b$ and $c$ ($1 \le a, b, c \le 7\cdot10^8$) — the number of daily rations of fish food, rabbit stew and chicken stakes in Polycarps backpack correspondingly.
-----Output-----
Print the maximum number of days the cat can eat in a trip without additional food purchases, if Polycarp chooses the day of the week to start his trip optimally.
-----Examples-----
Input
2 1 1
Output
4
Input
3 2 2
Output
7
Input
1 100 1
Output
3
Input
30 20 10
Output
39
-----Note-----
In the first example the best day for start of the trip is Sunday. In this case, during Sunday and Monday the cat will eat fish food, during Tuesday — rabbit stew and during Wednesday — chicken stake. So, after four days of the trip all food will be eaten.
In the second example Polycarp can start his trip in any day of the week. In any case there are food supplies only for one week in Polycarps backpack.
In the third example Polycarp can start his trip in any day, excluding Wednesday, Saturday and Sunday. In this case, the cat will eat three different dishes in three days. Nevertheless that after three days of a trip there will be $99$ portions of rabbit stew in a backpack, can cannot eat anything in fourth day of a trip.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
A, B, C = list(map(int, input().split()))
g = min(A//3,B//2,C//2)
A -= g*3
B -= g*2
C -= g*2
L = [0,0,1,2,0,2,1]
def calc(today, x):
if x[L[today]] == 0:
return 0
y = [xx for xx in x]
y[L[today]] -= 1
return calc((today+1)%7, y) + 1
ma = 0
for i in range(7):
ma = max(ma, calc(i, [A,B,C]))
print(ma+g*7)
``` | vfc_24807 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1154/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2 1 1\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 2 2\n",
"output": "7\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 100 1\n",
"output": "3\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4027 | Solve the following coding problem using the programming language python:
You are given an integer sequence $1, 2, \dots, n$. You have to divide it into two sets $A$ and $B$ in such a way that each element belongs to exactly one set and $|sum(A) - sum(B)|$ is minimum possible.
The value $|x|$ is the absolute value of $x$ and $sum(S)$ is the sum of elements of the set $S$.
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 2 \cdot 10^9$).
-----Output-----
Print one integer — the minimum possible value of $|sum(A) - sum(B)|$ if you divide the initial sequence $1, 2, \dots, n$ into two sets $A$ and $B$.
-----Examples-----
Input
3
Output
0
Input
5
Output
1
Input
6
Output
1
-----Note-----
Some (not all) possible answers to examples:
In the first example you can divide the initial sequence into sets $A = \{1, 2\}$ and $B = \{3\}$ so the answer is $0$.
In the second example you can divide the initial sequence into sets $A = \{1, 3, 4\}$ and $B = \{2, 5\}$ so the answer is $1$.
In the third example you can divide the initial sequence into sets $A = \{1, 4, 5\}$ and $B = \{2, 3, 6\}$ 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())
if n * (n + 1) // 2 % 2 == 1:
print(1)
else:
print(0)
``` | vfc_24815 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1102/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4028 | Solve the following coding problem using the programming language python:
You are given a bracket sequence $s$ (not necessarily a regular one). A bracket sequence is a string containing only characters '(' and ')'.
A regular bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters '1' and '+' between the original characters of the sequence. For example, bracket sequences "()()" and "(())" are regular (the resulting expressions are: "(1)+(1)" and "((1+1)+1)"), and ")(", "(" and ")" are not.
Your problem is to calculate the number of regular bracket sequences of length $2n$ containing the given bracket sequence $s$ as a substring (consecutive sequence of characters) modulo $10^9+7$ ($1000000007$).
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 100$) — the half-length of the resulting regular bracket sequences (the resulting sequences must have length equal to $2n$).
The second line of the input contains one string $s$ ($1 \le |s| \le 200$) — the string $s$ that should be a substring in each of the resulting regular bracket sequences ($|s|$ is the length of $s$).
-----Output-----
Print only one integer — the number of regular bracket sequences containing the given bracket sequence $s$ as a substring. Since this number can be huge, print it modulo $10^9+7$ ($1000000007$).
-----Examples-----
Input
5
()))()
Output
5
Input
3
(()
Output
4
Input
2
(((
Output
0
-----Note-----
All regular bracket sequences satisfying the conditions above for the first example: "(((()))())"; "((()()))()"; "((()))()()"; "(()(()))()"; "()((()))()".
All regular bracket sequences satisfying the conditions above for the second example: "((()))"; "(()())"; "(())()"; "()(())".
And there is no regular bracket sequences of length $4$ containing "(((" as a substring in the third example.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
MOD=10**9+7
n=int(input())
s=[c=='(' for c in input()]
m=len(s)
z=[[0,0]]
for v in s:
a=z[-1][v]
z[-1][v]=len(z)
z.append(z[a][:])
z[m][0]=z[m][1]=m
dp=[[0 for _ in range(m+1)] for _ in range(n+1)]
dp[0][0]=1
for _ in range(2*n):
ndp=[[0 for _ in range(m+1)] for _ in range(n+1)]
for i in range(n+1):
for j in range(m+1):
if dp[i][j]<1:continue
if i>0:ndp[i-1][z[j][0]]=(ndp[i-1][z[j][0]]+dp[i][j])%MOD
if i<n:ndp[i+1][z[j][1]]=(ndp[i+1][z[j][1]]+dp[i][j])%MOD
dp=ndp
print(dp[0][m])
``` | vfc_24819 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1015/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n()))()\n",
"output": "5\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n(()\n",
"output": "4\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4029 | Solve the following coding problem using the programming language python:
You are given an integer $n$ from $1$ to $10^{18}$ without leading zeroes.
In one move you can swap any two adjacent digits in the given number in such a way that the resulting number will not contain leading zeroes. In other words, after each move the number you have cannot contain any leading zeroes.
What is the minimum number of moves you have to make to obtain a number that is divisible by $25$? Print -1 if it is impossible to obtain a number that is divisible by $25$.
-----Input-----
The first line contains an integer $n$ ($1 \le n \le 10^{18}$). It is guaranteed that the first (left) digit of the number $n$ is not a zero.
-----Output-----
If it is impossible to obtain a number that is divisible by $25$, print -1. Otherwise print the minimum number of moves required to obtain such number.
Note that you can swap only adjacent digits in the given number.
-----Examples-----
Input
5071
Output
4
Input
705
Output
1
Input
1241367
Output
-1
-----Note-----
In the first example one of the possible sequences of moves is 5071 $\rightarrow$ 5701 $\rightarrow$ 7501 $\rightarrow$ 7510 $\rightarrow$ 7150.
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 queue
INFINITY = 10**10
def main():
n = input()
print(solve(n))
def solve(n):
if int(n) < 1000:
return brute(n)
forward = min([calc(str(n), last_digits) for last_digits in ["00", "25", "50", "75"]])
reverse = min([calc(str(n), last_digits) + 1 for last_digits in ["52", "05", "57"]])
res = min(forward, reverse)
if res >= INFINITY:
res = -1
return res
def calc(n, last_digits):
if not last_digits:
return 0
idx = n.rfind(last_digits[-1])
if idx == -1:
return INFINITY
res = len(n) - idx - 1
n = n[:idx] + n[(idx+1):]
last_digits = last_digits[:-1]
extra = 0
if n and n[0] == '0':
idx = len(n)
for digit in "123456789":
if n.find(digit) != -1:
idx = min(idx, n.find(digit))
if idx == len(n):
return idx
n = swap(n, 0, idx)
extra = idx
return res + calc(n, last_digits) + extra
def brute(n):
q = queue.Queue()
dis = dict()
q.put(str(n))
dis[str(n)] = 0
while not q.empty():
s = q.get()
if int(s) % 25 == 0:
return dis[s]
for i in range(1, len(s)):
j = i - 1
t = swap(s, i, j)
if t not in dis and t[0] != '0':
dis[t] = dis[s] + 1
q.put(t)
return -1
def swap(s, i, j):
chars = list(s)
chars[i], chars[j] = chars[j], chars[i]
return "".join(char for char in chars)
def __starting_point():
main()
__starting_point()
``` | vfc_24823 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/988/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5071\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "705\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4031 | Solve the following coding problem using the programming language python:
You are given $n$ strings. Each string consists of lowercase English letters. Rearrange (reorder) the given strings in such a way that for every string, all strings that are placed before it are its substrings.
String $a$ is a substring of string $b$ if it is possible to choose several consecutive letters in $b$ in such a way that they form $a$. For example, string "for" is contained as a substring in strings "codeforces", "for" and "therefore", but is not contained as a substring in strings "four", "fofo" and "rof".
-----Input-----
The first line contains an integer $n$ ($1 \le n \le 100$) — the number of strings.
The next $n$ lines contain the given strings. The number of letters in each string is from $1$ to $100$, inclusive. Each string consists of lowercase English letters.
Some strings might be equal.
-----Output-----
If it is impossible to reorder $n$ given strings in required order, print "NO" (without quotes).
Otherwise print "YES" (without quotes) and $n$ given strings in required order.
-----Examples-----
Input
5
a
aba
abacaba
ba
aba
Output
YES
a
ba
aba
aba
abacaba
Input
5
a
abacaba
ba
aba
abab
Output
NO
Input
3
qwerty
qwerty
qwerty
Output
YES
qwerty
qwerty
qwerty
-----Note-----
In the second example you cannot reorder the strings because the string "abab" is not a substring of the string "abacaba".
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())
arr = [input() for _ in range(n)]
arr.sort(key = lambda x : len(x))
for u, v in zip(arr[:-1], arr[1:]):
if u not in v:
print('NO')
return
print('YES')
print('\n'.join(x for x in arr))
``` | vfc_24831 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/988/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\na\naba\nabacaba\nba\naba\n",
"output": "YES\na\nba\naba\naba\nabacaba\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\na\nabacaba\nba\naba\nabab\n",
"output": "NO\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4032 | Solve the following coding problem using the programming language python:
Mishka started participating in a programming contest. There are $n$ problems in the contest. Mishka's problem-solving skill is equal to $k$.
Mishka arranges all problems from the contest into a list. Because of his weird principles, Mishka only solves problems from one of the ends of the list. Every time, he chooses which end (left or right) he will solve the next problem from. Thus, each problem Mishka solves is either the leftmost or the rightmost problem in the list.
Mishka cannot solve a problem with difficulty greater than $k$. When Mishka solves the problem, it disappears from the list, so the length of the list decreases by $1$. Mishka stops when he is unable to solve any problem from any end of the list.
How many problems can Mishka solve?
-----Input-----
The first line of input contains two integers $n$ and $k$ ($1 \le n, k \le 100$) — the number of problems in the contest and Mishka's problem-solving skill.
The second line of input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 100$), where $a_i$ is the difficulty of the $i$-th problem. The problems are given in order from the leftmost to the rightmost in the list.
-----Output-----
Print one integer — the maximum number of problems Mishka can solve.
-----Examples-----
Input
8 4
4 2 3 1 5 1 6 4
Output
5
Input
5 2
3 1 2 1 3
Output
0
Input
5 100
12 34 55 43 21
Output
5
-----Note-----
In the first example, Mishka can solve problems in the following order: $[4, 2, 3, 1, 5, 1, 6, 4] \rightarrow [2, 3, 1, 5, 1, 6, 4] \rightarrow [2, 3, 1, 5, 1, 6] \rightarrow [3, 1, 5, 1, 6] \rightarrow [1, 5, 1, 6] \rightarrow [5, 1, 6]$, so the number of solved problems will be equal to $5$.
In the second example, Mishka can't solve any problem because the difficulties of problems from both ends are greater than $k$.
In the third example, Mishka's solving skill is so amazing that he can solve all the problems.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
input = __import__('sys').stdin.readline
MIS = lambda: map(int,input().split())
n, k = MIS()
prob = list(MIS())
while prob and prob[0] <= k: prob.pop(0)
while prob and prob[-1] <= k: prob.pop()
print(n - len(prob))
``` | vfc_24835 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/999/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "8 4\n4 2 3 1 5 1 6 4\n",
"output": "5\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 2\n3 1 2 1 3\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 100\n12 34 55 43 21\n",
"output": "5\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "100 100\n44 47 36 83 76 94 86 69 31 2 22 77 37 51 10 19 25 78 53 25 1 29 48 95 35 53 22 72 49 86 60 38 13 91 89 18 54 19 71 2 25 33 65 49 53 5 95 90 100 68 25 5 87 48 45 72 34 14 100 44 94 75 80 26 25 7 57 82 49 73 55 43 42 60 34 8 51 11 71 41 81 23 20 89 12 72 68 26 96 92 32 63 13 47 19 9 35 56 79 62\n",
"output": "100\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4033 | Solve the following coding problem using the programming language python:
There is an infinite board of square tiles. Initially all tiles are white.
Vova has a red marker and a blue marker. Red marker can color $a$ tiles. Blue marker can color $b$ tiles. If some tile isn't white then you can't use marker of any color on it. Each marker must be drained completely, so at the end there should be exactly $a$ red tiles and exactly $b$ blue tiles across the board.
Vova wants to color such a set of tiles that:
they would form a rectangle, consisting of exactly $a+b$ colored tiles; all tiles of at least one color would also form a rectangle.
Here are some examples of correct colorings:
[Image]
Here are some examples of incorrect colorings:
[Image]
Among all correct colorings Vova wants to choose the one with the minimal perimeter. What is the minimal perimeter Vova can obtain?
It is guaranteed that there exists at least one correct coloring.
-----Input-----
A single line contains two integers $a$ and $b$ ($1 \le a, b \le 10^{14}$) — the number of tiles red marker should color and the number of tiles blue marker should color, respectively.
-----Output-----
Print a single integer — the minimal perimeter of a colored rectangle Vova can obtain by coloring exactly $a$ tiles red and exactly $b$ tiles blue.
It is guaranteed that there exists at least one correct coloring.
-----Examples-----
Input
4 4
Output
12
Input
3 9
Output
14
Input
9 3
Output
14
Input
3 6
Output
12
Input
506 2708
Output
3218
-----Note-----
The first four examples correspond to the first picture of the statement.
Note that for there exist multiple correct colorings for all of the examples.
In the first example you can also make a rectangle with sides $1$ and $8$, though its perimeter will be $18$ which is greater than $8$.
In the second example you can make the same resulting rectangle with sides $3$ and $4$, but red tiles will form the rectangle with sides $1$ and $3$ and blue tiles will form the rectangle with sides $3$ and $3$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import math
a,b = [int(x) for x in input().split()]
area = a+b
t = int(math.sqrt(area))
sa = int(math.sqrt(a))
sb = int(math.sqrt(b))
D = []
DA = []
DB = []
for i in range(1,t+1):
if area % i == 0:
if i*i != area:
D.append(i)
D.append(area//i)
else:
D.append(i)
for i in range(1,sa+1):
if a % i == 0:
if i*i != a:
DA.append(i)
DA.append(a//i)
else:
DA.append(i)
for i in range(1,sb+1):
if b % i == 0:
if i*i != b:
DB.append(i)
DB.append(b//i)
else:
DB.append(i)
DA.sort()
DB.sort()
D.sort()
start = ((len(D)+1)//2)-1
div = len(D)
def closestdiv(t,D):
low = 0
high = len(D)-1
while high - low > 1:
guess = (high+low)//2
if D[guess] > t:
high = guess
else:
low = guess
if D[high] <= t:
return high
else:
return low
while start > -1:
t = D[start]
s = D[-start-1]
if DA[-closestdiv(t,DA)-1] <= s:
print(2*t+2*s)
break
elif DB[-closestdiv(t,DB)-1] <= s:
print(2*t+2*s)
break
start -= 1
``` | vfc_24839 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1029/F",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 4\n",
"output": "12\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 9\n",
"output": "14\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "9 3\n",
"output": "14\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 6\n",
"output": "12\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "506 2708\n",
"output": "3218\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4034 | Solve the following coding problem using the programming language python:
This is an easy version of the problem. The actual problems are different, but the easy version is almost a subtask of the hard version. Note that the constraints and the output format are different.
You are given a string $s$ consisting of $n$ lowercase Latin letters.
You have to color all its characters one of the two colors (each character to exactly one color, the same letters can be colored the same or different colors, i.e. you can choose exactly one color for each index in $s$).
After coloring, you can swap any two neighboring characters of the string that are colored different colors. You can perform such an operation arbitrary (possibly, zero) number of times.
The goal is to make the string sorted, i.e. all characters should be in alphabetical order.
Your task is to say if it is possible to color the given string so that after coloring it can become sorted by some sequence of swaps. Note that you have to restore only coloring, not the sequence of swaps.
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 200$) — the length of $s$.
The second line of the input contains the string $s$ consisting of exactly $n$ lowercase Latin letters.
-----Output-----
If it is impossible to color the given string so that after coloring it can become sorted by some sequence of swaps, print "NO" (without quotes) in the first line.
Otherwise, print "YES" in the first line and any correct coloring in the second line (the coloring is the string consisting of $n$ characters, the $i$-th character should be '0' if the $i$-th character is colored the first color and '1' otherwise).
-----Examples-----
Input
9
abacbecfd
Output
YES
001010101
Input
8
aaabbcbb
Output
YES
01011011
Input
7
abcdedc
Output
NO
Input
5
abcde
Output
YES
00000
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 = int(input())
s = input()
graph = {}
for i in range(n):
graph[i] = set()
rb = set()
for i in range(n):
for j in range(i + 1, n):
if s[i] > s[j]:
graph[i].add(j)
graph[j].add(i)
rb.add((i, j))
rb.add((j, i))
group = [0] * n
used = [0] * n
for p in range(n):
if not used[p]:
used[p] = 1
q = deque([p])
group[p] = 0
while q:
v = q.popleft()
for u in graph[v]:
if not used[u]:
used[u] = 1
q.append(u)
group[u] = 1 - group[v]
g1, g2 = set(), set()
for i in range(n):
if group[i] == 0:
g1.add(i)
else:
g2.add(i)
for p in g1:
for p2 in g1:
if (p, p2) in rb:
print('NO')
return
for p in g2:
for p2 in g2:
if (p, p2) in rb:
print('NO')
return
print('YES')
for i in range(n):
if i in g1:
print('0', end='')
else:
print('1', end='')
``` | vfc_24843 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1296/E1",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "9\nabacbecfd\n",
"output": "YES\n001010101\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "8\naaabbcbb\n",
"output": "YES\n00000011\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "7\nabcdedc\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\nabcde\n",
"output": "YES\n00000\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "200\nraaaaabbbccccccccccdddddeeeeeeeeeeeeeeffffffffffggggggggghhhhhiiiiiiiiijjjjkkkkkkkkkkllllllllmmmmmmmmnnnnnnnooooooooppppppqqqqqqqqqqrrrrrrrrssssttttttttttuuuuuuuuvvvvvvwwwwwwxxxxxxxyyyyyyyzzzzzzzzzzzz\n",
"output": "YES\n01111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000000000000000000000000000000000000000000000000000000000000000000\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4036 | Solve the following coding problem using the programming language python:
Polycarp has to solve exactly $n$ problems to improve his programming skill before an important programming competition. But this competition will be held very soon, most precisely, it will start in $k$ days. It means that Polycarp has exactly $k$ days for training!
Polycarp doesn't want to procrastinate, so he wants to solve at least one problem during each of $k$ days. He also doesn't want to overwork, so if he solves $x$ problems during some day, he should solve no more than $2x$ problems during the next day. And, at last, he wants to improve his skill, so if he solves $x$ problems during some day, he should solve at least $x+1$ problem during the next day.
More formally: let $[a_1, a_2, \dots, a_k]$ be the array of numbers of problems solved by Polycarp. The $i$-th element of this array is the number of problems Polycarp solves during the $i$-th day of his training. Then the following conditions must be satisfied: sum of all $a_i$ for $i$ from $1$ to $k$ should be $n$; $a_i$ should be greater than zero for each $i$ from $1$ to $k$; the condition $a_i < a_{i + 1} \le 2 a_i$ should be satisfied for each $i$ from $1$ to $k-1$.
Your problem is to find any array $a$ of length $k$ satisfying the conditions above or say that it is impossible to do it.
-----Input-----
The first line of the input contains two integers $n$ and $k$ ($1 \le n \le 10^9, 1 \le k \le 10^5$) — the number of problems Polycarp wants to solve and the number of days Polycarp wants to train.
-----Output-----
If it is impossible to find any array $a$ of length $k$ satisfying Polycarp's rules of training, print "NO" in the first line.
Otherwise print "YES" in the first line, then print $k$ integers $a_1, a_2, \dots, a_k$ in the second line, where $a_i$ should be the number of problems Polycarp should solve during the $i$-th day. If there are multiple answers, you can print any.
-----Examples-----
Input
26 6
Output
YES
1 2 4 5 6 8
Input
8 3
Output
NO
Input
1 1
Output
YES
1
Input
9 4
Output
NO
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
"""
b[i] = a[i] - i - 1
b[i] <= b[i+1] < 2b[i] + i - 1
sum(b) == r
"""
def solve(n, k):
r = n - k*(k+1)//2
if r < 0:
return None
b0 = r//k
r -= b0*k
seq = [None]*k
seq[0] = b0
b = b0
for i in range(1,k):
bn = b*2 + i - 1
h = r//(k-i)
if h > 0:
if h+b > bn:
h = bn - b
r -= h*(k-i)
b = h+b
seq[i] = b
if r != 0:
return None
A = [b+i+1 for i,b in enumerate(seq)]
return A
def main():
n,k = map(int,input().split())
res = solve(n,k)
if res is None:
print('NO')
else:
print('YES')
print(*res)
main()
``` | vfc_24851 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1157/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "26 6\n",
"output": "YES\n1 2 4 5 6 8 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "8 3\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 1\n",
"output": "YES\n1 \n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4037 | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions is that you should complete all the projects in easy version but this is not necessary in hard version.
Polycarp is a very famous freelancer. His current rating is $r$ units.
Some very rich customers asked him to complete some projects for their companies. To complete the $i$-th project, Polycarp needs to have at least $a_i$ units of rating; after he completes this project, his rating will change by $b_i$ (his rating will increase or decrease by $b_i$) ($b_i$ can be positive or negative). Polycarp's rating should not fall below zero because then people won't trust such a low rated freelancer.
Polycarp can choose the order in which he completes projects. Furthermore, he can even skip some projects altogether.
To gain more experience (and money, of course) Polycarp wants to choose the subset of projects having maximum possible size and the order in which he will complete them, so he has enough rating before starting each project, and has non-negative rating after completing each project.
Your task is to calculate the maximum possible size of such subset of projects.
-----Input-----
The first line of the input contains two integers $n$ and $r$ ($1 \le n \le 100, 1 \le r \le 30000$) — the number of projects and the initial rating of Polycarp, respectively.
The next $n$ lines contain projects, one per line. The $i$-th project is represented as a pair of integers $a_i$ and $b_i$ ($1 \le a_i \le 30000$, $-300 \le b_i \le 300$) — the rating required to complete the $i$-th project and the rating change after the project completion.
-----Output-----
Print one integer — the size of the maximum possible subset (possibly, empty) of projects Polycarp can choose.
-----Examples-----
Input
3 4
4 6
10 -2
8 -1
Output
3
Input
5 20
45 -6
34 -15
10 34
1 27
40 -45
Output
5
Input
3 2
300 -300
1 299
1 123
Output
3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
'''input
5 20
45 -6
34 -15
10 34
1 27
40 -45
'''
import sys
from collections import defaultdict as dd
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())
n, r = ri()
eventspos = []
eventsneg = []
for i in range(n):
temp =ri()
if temp[1]>=0:
eventspos.append(temp)
else:
eventsneg.append(temp)
eventspos.sort()
eventsneg.sort(key = lambda x: x[0]+x[1])
eventsneg.reverse()
status =1
ans=0
for i in range(len(eventspos)):
if eventspos[i][0] <= r:
r+= eventspos[i][1]
ans+=1
else:
status = 0
check = [0 for i in range(r+1)]
#print(eventsneg)
for i in range(len(eventsneg)):
for j in range(eventsneg[i][0] , r+1):
if j+eventsneg[i][1]>=0:
check[j+eventsneg[i][1]] = max(check[j+eventsneg[i][1]] , check[j]+1)
# if status and r>=0 and sum(check)==len(check):
# print("YES")
# else:
# print("NO")
#print(eventsneg,eventspos)
print(max(check) + ans )
``` | vfc_24855 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1203/F2",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 4\n4 6\n10 -2\n8 -1\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 20\n45 -6\n34 -15\n10 34\n1 27\n40 -45\n",
"output": "5\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 2\n300 -300\n1 299\n1 123\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "20 15000\n57 -299\n354 -298\n156 -298\n102 -298\n862 -300\n134 -300\n1446 -289\n23 -298\n1012 -298\n901 -300\n97 -300\n172 -297\n108 -265\n209 -294\n307 -300\n28 -295\n1021 -295\n666 -296\n83 -298\n469 -298\n",
"output": "20\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4039 | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions is that you should complete all the projects in easy version but this is not necessary in hard version.
Polycarp is a very famous freelancer. His current rating is $r$ units.
Some very rich customers asked him to complete some projects for their companies. To complete the $i$-th project, Polycarp needs to have at least $a_i$ units of rating; after he completes this project, his rating will change by $b_i$ (his rating will increase or decrease by $b_i$) ($b_i$ can be positive or negative). Polycarp's rating should not fall below zero because then people won't trust such a low rated freelancer.
Is it possible to complete all the projects? Formally, write a program to check if such an order of the projects exists, that Polycarp has enough rating before starting each project, and he has non-negative rating after completing each project.
In other words, you have to check that there exists such an order of projects in which Polycarp will complete them, so he has enough rating before starting each project, and has non-negative rating after completing each project.
-----Input-----
The first line of the input contains two integers $n$ and $r$ ($1 \le n \le 100, 1 \le r \le 30000$) — the number of projects and the initial rating of Polycarp, respectively.
The next $n$ lines contain projects, one per line. The $i$-th project is represented as a pair of integers $a_i$ and $b_i$ ($1 \le a_i \le 30000$, $-300 \le b_i \le 300$) — the rating required to complete the $i$-th project and the rating change after the project completion.
-----Output-----
Print "YES" or "NO".
-----Examples-----
Input
3 4
4 6
10 -2
8 -1
Output
YES
Input
3 5
4 -5
4 -2
1 3
Output
YES
Input
4 4
5 2
5 -3
2 1
4 -2
Output
YES
Input
3 10
10 0
10 -10
30 0
Output
NO
-----Note-----
In the first example, the possible order is: $1, 2, 3$.
In the second example, the possible order is: $2, 3, 1$.
In the third example, the possible order is: $3, 1, 4, 2$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def sign(x):
return (x > 0) - (x < 0)
def key(ab):
a, b = ab
return (2, -a - b) if b < 0 else (1, a)
def main():
n, r = list(map(int, input().split()))
for a, b in sorted((tuple(map(int, input().split())) for _ in range(n)), key=key):
if r < a:
r = -1
break
r += b
if r < 0:
print("NO")
else:
print("YES")
main()
``` | vfc_24863 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1203/F1",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 4\n4 6\n10 -2\n8 -1\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 5\n4 -5\n4 -2\n1 3\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 4\n5 2\n5 -3\n2 1\n4 -2\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 10\n10 0\n10 -10\n30 0\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "52 276\n303 6\n222 -6\n28 0\n93 6\n96 7\n223 0\n154 -4\n309 -7\n329 6\n94 3\n11 -3\n126 0\n210 2\n101 7\n154 4\n54 6\n33 5\n324 -4\n86 5\n220 -2\n137 -1\n49 -4\n109 6\n107 4\n270 2\n209 -2\n235 -5\n39 1\n110 5\n116 4\n155 1\n37 -1\n193 0\n356 -1\n320 -6\n261 -7\n316 6\n137 2\n165 2\n350 7\n224 6\n89 3\n149 7\n348 3\n271 3\n52 -5\n186 -5\n13 0\n173 -6\n285 2\n20 -5\n152 -5\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 1\n1 0\n",
"output": "YES\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4041 | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions is the length of the string.
You are given a string $s$ and a string $t$, both consisting only of lowercase Latin letters. It is guaranteed that $t$ can be obtained from $s$ by removing some (possibly, zero) number of characters (not necessary contiguous) from $s$ without changing order of remaining characters (in other words, it is guaranteed that $t$ is a subsequence of $s$).
For example, the strings "test", "tst", "tt", "et" and "" are subsequences of the string "test". But the strings "tset", "se", "contest" are not subsequences of the string "test".
You want to remove some substring (contiguous subsequence) from $s$ of maximum possible length such that after removing this substring $t$ will remain a subsequence of $s$.
If you want to remove the substring $s[l;r]$ then the string $s$ will be transformed to $s_1 s_2 \dots s_{l-1} s_{r+1} s_{r+2} \dots s_{|s|-1} s_{|s|}$ (where $|s|$ is the length of $s$).
Your task is to find the maximum possible length of the substring you can remove so that $t$ is still a subsequence of $s$.
-----Input-----
The first line of the input contains one string $s$ consisting of at least $1$ and at most $200$ lowercase Latin letters.
The second line of the input contains one string $t$ consisting of at least $1$ and at most $200$ lowercase Latin letters.
It is guaranteed that $t$ is a subsequence of $s$.
-----Output-----
Print one integer — the maximum possible length of the substring you can remove so that $t$ is still a subsequence of $s$.
-----Examples-----
Input
bbaba
bb
Output
3
Input
baaba
ab
Output
2
Input
abcde
abcde
Output
0
Input
asdfasdf
fasd
Output
3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
s = input()
t = input()
l, r = [0]*len(t), [0]*len(t)
li, ri = 0, len(s) - 1
for i in range(len(t)):
while s[ li ] != t[ i ]:
li += 1
while s[ ri ] != t[ - i - 1 ]:
ri -= 1
l[ i ] = li
r[ -i -1 ] = ri
li += 1
ri -= 1
print( max( [ r[ 0 ], len(s) - l[ -1 ] - 1 ] + [ max( 0, r[ i ] - l[ i - 1 ] ) - 1 for i in range( 1, len(t) ) ] ) )
``` | vfc_24871 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1203/D1",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "bbaba\nbb\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "baaba\nab\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4042 | Solve the following coding problem using the programming language python:
$\text{A}$
-----Input-----
The input contains a single floating-point number x with exactly 6 decimal places (0 < x < 5).
-----Output-----
Output two integers separated by a single space. Each integer should be between 1 and 10, inclusive. If several solutions exist, output any of them. Solution will exist for all tests.
-----Examples-----
Input
1.200000
Output
3 2
Input
2.572479
Output
10 3
Input
4.024922
Output
9 9
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
r=float(input())
a=0
h=0
for i in range(1,11):
for j in range(1,11):
c=pow(j*j+i*i/4.,0.5)
rtest=i*j*0.5/c
if abs(rtest-r)<0.00001:
a=i
h=j
print(a,h)
``` | vfc_24875 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/409/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "1.200000\n",
"output": "3 2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2.572479\n",
"output": "10 3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4.024922\n",
"output": "9 9\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "0.447214\n",
"output": "1 1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "0.493197\n",
"output": "1 3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "0.496139\n",
"output": "1 4\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4043 | Solve the following coding problem using the programming language python:
You are given three integers $n$, $d$ and $k$.
Your task is to construct an undirected tree on $n$ vertices with diameter $d$ and degree of each vertex at most $k$, or say that it is impossible.
An undirected tree is a connected undirected graph with $n - 1$ edges.
Diameter of a tree is the maximum length of a simple path (a path in which each vertex appears at most once) between all pairs of vertices of this tree.
Degree of a vertex is the number of edges incident to this vertex (i.e. for a vertex $u$ it is the number of edges $(u, v)$ that belong to the tree, where $v$ is any other vertex of a tree).
-----Input-----
The first line of the input contains three integers $n$, $d$ and $k$ ($1 \le n, d, k \le 4 \cdot 10^5$).
-----Output-----
If there is no tree satisfying the conditions above, print only one word "NO" (without quotes).
Otherwise in the first line print "YES" (without quotes), and then print $n - 1$ lines describing edges of a tree satisfying the conditions above. Vertices of the tree must be numbered from $1$ to $n$. You can print edges and vertices connected by an edge in any order. If there are multiple answers, print any of them.1
-----Examples-----
Input
6 3 3
Output
YES
3 1
4 1
1 2
5 2
2 6
Input
6 2 3
Output
NO
Input
10 4 3
Output
YES
2 9
2 10
10 3
3 1
6 10
8 2
4 3
5 6
6 7
Input
8 5 3
Output
YES
2 5
7 2
3 7
3 1
1 6
8 7
4 3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n,d,k=list(map(int,input().strip().split()))
ans=[]
if (d>n-1):
print ("NO")
return
if (k<2 and n>2):
print ("NO")
return
l1=[0 for i in range(d+2)]
count=d
cnt=d+2
def insert(par,v,r,e):
nonlocal count
nonlocal cnt
if count==n-1:
print ("YES")
for o in ans:
print(o[0],o[1])
return
else:
ans.append([par,v])
cnt=cnt+1
count=count+1
if (e==0):
return
while(r!=0):
insert(v,cnt,k-1,e-1)
r=r-1
return
for i in range(1,d+1):
ans.append([i,i+1])
for i in range(1,d+2):
l1[i]=min(i-1,d+1-i)
for i in range(2,d+1):
r=k-2
while(r!=0):
insert(i,cnt,k-1,l1[i]-1)
r=r-1
if (count<n-1):
print ("NO")
else:
print ("YES")
for o in ans:
print(o[0],o[1])
return
``` | vfc_24879 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1003/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6 3 3\n",
"output": "YES\n2 5\n4 2\n3 4\n2 1\n4 6\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4044 | Solve the following coding problem using the programming language python:
You are given three integers $a$, $b$ and $x$. Your task is to construct a binary string $s$ of length $n = a + b$ such that there are exactly $a$ zeroes, exactly $b$ ones and exactly $x$ indices $i$ (where $1 \le i < n$) such that $s_i \ne s_{i + 1}$. It is guaranteed that the answer always exists.
For example, for the string "01010" there are four indices $i$ such that $1 \le i < n$ and $s_i \ne s_{i + 1}$ ($i = 1, 2, 3, 4$). For the string "111001" there are two such indices $i$ ($i = 3, 5$).
Recall that binary string is a non-empty sequence of characters where each character is either 0 or 1.
-----Input-----
The first line of the input contains three integers $a$, $b$ and $x$ ($1 \le a, b \le 100, 1 \le x < a + b)$.
-----Output-----
Print only one string $s$, where $s$ is any binary string satisfying conditions described above. It is guaranteed that the answer always exists.
-----Examples-----
Input
2 2 1
Output
1100
Input
3 3 3
Output
101100
Input
5 3 6
Output
01010100
-----Note-----
All possible answers for the first example: 1100; 0011.
All possible answers for the second example: 110100; 101100; 110010; 100110; 011001; 001101; 010011; 001011.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
a,b,x=list(map(int,input().split()))
if(a>b):
s='0'
a-=1
else:
s='1'
b-=1
for i in range(x-1):
if(s[-1]=='1'):
s+='0'
a-=1
else:
s+='1'
b-=1
if(s[-1]=='1'):
s+='1'*(b)
s+='0'*a
else:
s+='0'*a
s+='1'*b
print(s)
``` | vfc_24883 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1003/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2 2 1\n",
"output": "1100\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4045 | Solve the following coding problem using the programming language python:
You are given two strings $s$ and $t$ both of length $2$ and both consisting only of characters 'a', 'b' and 'c'.
Possible examples of strings $s$ and $t$: "ab", "ca", "bb".
You have to find a string $res$ consisting of $3n$ characters, $n$ characters should be 'a', $n$ characters should be 'b' and $n$ characters should be 'c' and $s$ and $t$ should not occur in $res$ as substrings.
A substring of a string is a contiguous subsequence of that string. So, the strings "ab", "ac" and "cc" are substrings of the string "abacc", but the strings "bc", "aa" and "cb" are not substrings of the string "abacc".
If there are multiple answers, you can print any of them.
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 10^5$) — the number of characters 'a', 'b' and 'c' in the resulting string.
The second line of the input contains one string $s$ of length $2$ consisting of characters 'a', 'b' and 'c'.
The third line of the input contains one string $t$ of length $2$ consisting of characters 'a', 'b' and 'c'.
-----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 $res$ on the second line. $res$ should consist of $3n$ characters, $n$ characters should be 'a', $n$ characters should be 'b' and $n$ characters should be 'c' and $s$ and $t$ should not occur in $res$ as substrings.
If there are multiple answers, you can print any of them.
-----Examples-----
Input
2
ab
bc
Output
YES
acbbac
Input
3
aa
bc
Output
YES
cacbacbab
Input
1
cb
ac
Output
YES
abc
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())
s = input()
t = input()
#n = 1
#s2 = ["aa", "ab", "ac", "ba", "bb", "bc", "ca", "cb", "cc"]
us = ["abc", "acb", "bac", "bca", "cab", "cba"]
flag = 0
for u in us:
if (s in u or t in u):
continue
if (n > 1 and (s in (u[2] + u[0]) or t in (u[2] + u[0]))):
continue
flag = 1
print("YES")
print(u * n)
return
if (not flag):
for u in us:
if (s in u or t in u):
continue
print("YES")
print(u[0] * n + u[1] * n + u[2] * n)
return
``` | vfc_24887 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1213/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\nab\nbc\n",
"output": "YES\nacbacb\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4046 | Solve the following coding problem using the programming language python:
An array of integers $p_1, p_2, \dots, p_n$ is called a permutation if it contains each number from $1$ to $n$ exactly once. For example, the following arrays are permutations: $[3, 1, 2]$, $[1]$, $[1, 2, 3, 4, 5]$ and $[4, 3, 1, 2]$. The following arrays are not permutations: $[2]$, $[1, 1]$, $[2, 3, 4]$.
Polycarp invented a really cool permutation $p_1, p_2, \dots, p_n$ of length $n$. It is very disappointing, but he forgot this permutation. He only remembers the array $q_1, q_2, \dots, q_{n-1}$ of length $n-1$, where $q_i=p_{i+1}-p_i$.
Given $n$ and $q=q_1, q_2, \dots, q_{n-1}$, help Polycarp restore the invented permutation.
-----Input-----
The first line contains the integer $n$ ($2 \le n \le 2\cdot10^5$) — the length of the permutation to restore. The second line contains $n-1$ integers $q_1, q_2, \dots, q_{n-1}$ ($-n < q_i < n$).
-----Output-----
Print the integer -1 if there is no such permutation of length $n$ which corresponds to the given array $q$. Otherwise, if it exists, print $p_1, p_2, \dots, p_n$. Print any such permutation if there are many of them.
-----Examples-----
Input
3
-2 1
Output
3 1 2
Input
5
1 1 1 1
Output
1 2 3 4 5
Input
4
-1 2 2
Output
-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())
a = list(map(int, input().split()))
a = [0] + a
for i in range(1, n):
a[i] += a[i - 1]
mi = min(a)
a = list([x - mi + 1 for x in a])
print(-1 if set(a) != set(range(1, n + 1)) else ' '.join(map(str, a)))
``` | vfc_24891 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1141/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n-2 1\n",
"output": "3 1 2 ",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4047 | Solve the following coding problem using the programming language python:
You are given $n$ chips on a number line. The $i$-th chip is placed at the integer coordinate $x_i$. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
Move the chip $i$ by $2$ to the left or $2$ to the right for free (i.e. replace the current coordinate $x_i$ with $x_i - 2$ or with $x_i + 2$); move the chip $i$ by $1$ to the left or $1$ to the right and pay one coin for this move (i.e. replace the current coordinate $x_i$ with $x_i - 1$ or with $x_i + 1$).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all $n$ chips to the same coordinate (i.e. all $x_i$ should be equal after some sequence of moves).
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 100$) — the number of chips.
The second line of the input contains $n$ integers $x_1, x_2, \dots, x_n$ ($1 \le x_i \le 10^9$), where $x_i$ is the coordinate of the $i$-th chip.
-----Output-----
Print one integer — the minimum total number of coins required to move all $n$ chips to the same coordinate.
-----Examples-----
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
-----Note-----
In the first example you need to move the first chip by $2$ to the right and the second chip by $1$ to the right or move the third chip by $2$ to the left and the second chip by $1$ to the left so the answer is $1$.
In the second example you need to move two chips with coordinate $3$ by $1$ to the left so the answer is $2$.
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()))
for i in range(n):
A[i] %= 2
print(min(n - A.count(0), A.count(0)))
``` | vfc_24895 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1213/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n1 2 3\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4049 | Solve the following coding problem using the programming language python:
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser; if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser; if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly $n$ rounds of the game described above. Alice decided to show rock $a_1$ times, show scissors $a_2$ times and show paper $a_3$ times. Bob decided to show rock $b_1$ times, show scissors $b_2$ times and show paper $b_3$ times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that $a_1 + a_2 + a_3 = n$ and $b_1 + b_2 + b_3 = n$.
Your task is to find two numbers:
the minimum number of round Alice can win; the maximum number of rounds Alice can win.
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 10^{9}$) — the number of rounds.
The second line of the input contains three integers $a_1, a_2, a_3$ ($0 \le a_i \le n$) — the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that $a_1 + a_2 + a_3 = n$.
The third line of the input contains three integers $b_1, b_2, b_3$ ($0 \le b_j \le n$) — the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that $b_1 + b_2 + b_3 = n$.
-----Output-----
Print two integers: the minimum and the maximum number of rounds Alice can win.
-----Examples-----
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
-----Note-----
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway.
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
x = int(input())
# 묵 찌 빠
a = list(map(int, input().split()))
b = list(map(int, input().split()))
MAX = min(a[0], b[1])+min(a[1], b[2])+min(a[2], b[0])
MIN = 0
tmp = min(a[0], b[0]+b[2])
a[0] -= tmp
ttmp = min(a[1], b[0]+b[1])
a[1] -= ttmp
tttmp = min(a[2], b[1]+b[2])
a[2] -= tttmp
print(sum(a), MAX)
``` | vfc_24903 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1426/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n0 1 1\n1 1 0\n",
"output": "0 1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4050 | Solve the following coding problem using the programming language python:
This problem is given in two editions, which differ exclusively in the constraints on the number $n$.
You are given an array of integers $a[1], a[2], \dots, a[n].$ A block is a sequence of contiguous (consecutive) elements $a[l], a[l+1], \dots, a[r]$ ($1 \le l \le r \le n$). Thus, a block is defined by a pair of indices $(l, r)$.
Find a set of blocks $(l_1, r_1), (l_2, r_2), \dots, (l_k, r_k)$ such that:
They do not intersect (i.e. they are disjoint). Formally, for each pair of blocks $(l_i, r_i)$ and $(l_j, r_j$) where $i \neq j$ either $r_i < l_j$ or $r_j < l_i$. For each block the sum of its elements is the same. Formally, $$a[l_1]+a[l_1+1]+\dots+a[r_1]=a[l_2]+a[l_2+1]+\dots+a[r_2]=$$ $$\dots =$$ $$a[l_k]+a[l_k+1]+\dots+a[r_k].$$ The number of the blocks in the set is maximum. Formally, there does not exist a set of blocks $(l_1', r_1'), (l_2', r_2'), \dots, (l_{k'}', r_{k'}')$ satisfying the above two requirements with $k' > k$.
$\left. \begin{array}{|l|l|l|l|l|l|} \hline 4 & {1} & {2} & {2} & {1} & {5} & {3} \\ \hline \end{array} \right.$ The picture corresponds to the first example. Blue boxes illustrate blocks.
Write a program to find such a set of blocks.
-----Input-----
The first line contains integer $n$ ($1 \le n \le 50$) — the length of the given array. The second line contains the sequence of elements $a[1], a[2], \dots, a[n]$ ($-10^5 \le a_i \le 10^5$).
-----Output-----
In the first line print the integer $k$ ($1 \le k \le n$). The following $k$ lines should contain blocks, one per line. In each line print a pair of indices $l_i, r_i$ ($1 \le l_i \le r_i \le n$) — the bounds of the $i$-th block. You can print blocks in any order. If there are multiple answers, print any of them.
-----Examples-----
Input
7
4 1 2 2 1 5 3
Output
3
7 7
2 3
4 5
Input
11
-5 -4 -3 -2 -1 0 1 2 3 4 5
Output
2
3 4
1 1
Input
4
1 1 1 1
Output
4
4 4
1 1
2 2
3 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())
a = [int(x) for x in input().split()]
res = {}
for i in range(n):
sm = 0
for j in range(i, n):
sm += a[j]
if sm in res:
res[sm].append((i, j))
else:
res[sm] = [(i, j)]
best = 0
bestI = -1
for key in res:
r = -1
cnt = 0
for (a,b) in sorted(res[key]):
if a > r:
cnt += 1
r = b
elif b < r:
r = b
if cnt > best:
best = cnt
bestI = key
x = []
r = -1
for (a, b) in sorted(res[bestI]):
if a > r:
x.append(str(a+1) + " " + str(b+1))
r = b
elif b < r:
r = b
x.pop()
x.append(str(a+1) + " " + str(b+1))
print(best)
print("\n".join(x))
``` | vfc_24907 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1141/F1",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7\n4 1 2 2 1 5 3\n",
"output": "3\n7 7\n2 3\n4 5\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "11\n-5 -4 -3 -2 -1 0 1 2 3 4 5\n",
"output": "2\n3 4\n1 1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n1 1 1 1\n",
"output": "4\n4 4\n1 1\n2 2\n3 3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n100000\n",
"output": "1\n1 1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4051 | Solve the following coding problem using the programming language python:
Everybody knows of spaghetti sort. You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array a_{i}, build a stack of a_{i} ravioli. The image shows the stack for a_{i} = 4.
[Image]
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
-----Input-----
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers a_{i} (1 ≤ a_{i} ≤ 100) — the elements of the array.
-----Output-----
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
-----Examples-----
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
-----Note-----
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
"""
Codeforces April Fools 2018 Problem C
Author : chaotic_iak
Language: Python 3.5.2
"""
################################################### SOLUTION
def initialize_solution():
pass
def main():
n, = read()
a = read()
for i in range(n-1):
if abs(a[i] - a[i+1]) >= 2:
return "NO"
return "YES"
########################################## PROBLEM CONSTANTS
READ_FROM_FILE = None
OUTPUT_PREFIX = None
INTERACTIVE = False
#################################################### HELPERS
import sys
def read(callback=int, split=True):
if READ_FROM_FILE:
ipt = sfile.readline().strip()
else:
ipt = input().strip()
if INTERACTIVE and ipt == "WRONG_ANSWER":
return
if split:
return list(map(callback, ipt.split()))
else:
return callback(ipt)
def write(value, end="\n"):
if value is None: return
try:
if not isinstance(value, str):
value = " ".join(map(str, value))
except:
pass
if READ_FROM_FILE:
tfile.write(str(value, end=end))
else:
print(value, end=end)
if INTERACTIVE:
sys.stdout.flush()
sfile = None
tfile = None
if READ_FROM_FILE:
sfile = open(READ_FROM_FILE + ".in", "r")
sfile.seek(0)
tfile = open(READ_FROM_FILE + ".out", "w")
if OUTPUT_PREFIX is None:
result = main()
if result is not None:
write(result)
else:
initialize_solution()
TOTAL_CASES, = read()
for CASE_NUMBER in range(1, TOTAL_CASES+1):
write(OUTPUT_PREFIX.replace("%d", str(CASE_NUMBER)), end="")
result = main()
if result is not None:
write(result)
if sfile is not None: sfile.close()
if tfile is not None: tfile.close()
``` | vfc_24911 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/952/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n1 2 3\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n3 1 2\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n13\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n67 67 67 67 67 67 67 67 67 67\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n16 17 16 15 14 15 16 17 16 15\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n54 54 54 55\n",
"output": "YES\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4052 | Solve the following coding problem using the programming language python:
You are given two strings $s$ and $t$. Both strings have length $n$ and consist of lowercase Latin letters. The characters in the strings are numbered from $1$ to $n$.
You can successively perform the following move any number of times (possibly, zero): swap any two adjacent (neighboring) characters of $s$ (i.e. for any $i = \{1, 2, \dots, n - 1\}$ you can swap $s_i$ and $s_{i + 1})$.
You can't apply a move to the string $t$. The moves are applied to the string $s$ one after another.
Your task is to obtain the string $t$ from the string $s$. Find any way to do it with at most $10^4$ such moves.
You do not have to minimize the number of moves, just find any sequence of moves of length $10^4$ or less to transform $s$ into $t$.
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 50$) — the length of strings $s$ and $t$.
The second line of the input contains the string $s$ consisting of $n$ lowercase Latin letters.
The third line of the input contains the string $t$ consisting of $n$ lowercase Latin letters.
-----Output-----
If it is impossible to obtain the string $t$ using moves, print "-1".
Otherwise in the first line print one integer $k$ — the number of moves to transform $s$ to $t$. Note that $k$ must be an integer number between $0$ and $10^4$ inclusive.
In the second line print $k$ integers $c_j$ ($1 \le c_j < n$), where $c_j$ means that on the $j$-th move you swap characters $s_{c_j}$ and $s_{c_j + 1}$.
If you do not need to apply any moves, print a single integer $0$ in the first line and either leave the second line empty or do not print it at all.
-----Examples-----
Input
6
abcdef
abdfec
Output
4
3 5 4 5
Input
4
abcd
accd
Output
-1
-----Note-----
In the first example the string $s$ changes as follows: "abcdef" $\rightarrow$ "abdcef" $\rightarrow$ "abdcfe" $\rightarrow$ "abdfce" $\rightarrow$ "abdfec".
In the second example there is no way to transform the string $s$ into the string $t$ through any allowed moves.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
#
import collections, atexit, math, sys
from functools import cmp_to_key
#key=cmp_to_key(lambda x,y: 1 if x not in y else -1 )
sys.setrecursionlimit(1000000)
def getIntList():
return list(map(int, input().split()))
import bisect
try :
#raise ModuleNotFoundError
import numpy
def dprint(*args, **kwargs):
print(*args, **kwargs, file=sys.stderr)
dprint('debug mode')
except ModuleNotFoundError:
def dprint(*args, **kwargs):
pass
def memo(func):
cache={}
def wrap(*args):
if args not in cache:
cache[args]=func(*args)
return cache[args]
return wrap
@memo
def comb (n,k):
if k==0: return 1
if n==k: return 1
return comb(n-1,k-1) + comb(n-1,k)
inId = 0
outId = 0
if inId>0:
dprint('use input', inId)
sys.stdin = open('input'+ str(inId) + '.txt', 'r') #标准输出重定向至文件
if outId>0:
dprint('use output', outId)
sys.stdout = open('stdout'+ str(outId) + '.txt', 'w') #标准输出重定向至文件
atexit.register(lambda :sys.stdout.close()) #idle 中不会执行 atexit
N, = getIntList()
s = input()
t = input()
zs = list(s)
zt = list(t)
zs.sort()
zt.sort()
if zs != zt:
print(-1)
return
zs = list(s)
res = []
for i in range(N):
if zs[i] == t[i]: continue
for j in range(i+1,N):
if zs[j] == t[i]: break
for k in range(j-1,i-1, -1):
res.append(k)
zs[k],zs[k+1] = zs[k+1],zs[k]
print(len(res))
for x in res:
print(x+1,end = ' ')
``` | vfc_24915 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1015/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6\nabcdef\nabdfec\n",
"output": "4\n3 5 4 5 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\nabcd\naccd\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "50\nnyqahbyyoxltryqdmvenemaqnbakglgqolxnaifnqtoclnnqia\nnyqahbyyoxltryqdmvenemaqnbakglgqolxnaifnqtoclnnqia\n",
"output": "0\n\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "50\nnyqahbyyoxltryqdmvenemaqnbakglgqolxnaifnqtoclnnqia\nnyqahbyyoxluryqdmvenemaqnbakglgqolxnaifnqtoclnnqia\n",
"output": "-1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4053 | Solve the following coding problem using the programming language python:
Ivan wants to play a game with you. He picked some string $s$ of length $n$ consisting only of lowercase Latin letters.
You don't know this string. Ivan has informed you about all its improper prefixes and suffixes (i.e. prefixes and suffixes of lengths from $1$ to $n-1$), but he didn't tell you which strings are prefixes and which are suffixes.
Ivan wants you to guess which of the given $2n-2$ strings are prefixes of the given string and which are suffixes. It may be impossible to guess the string Ivan picked (since multiple strings may give the same set of suffixes and prefixes), but Ivan will accept your answer if there is at least one string that is consistent with it. Let the game begin!
-----Input-----
The first line of the input contains one integer number $n$ ($2 \le n \le 100$) — the length of the guessed string $s$.
The next $2n-2$ lines are contain prefixes and suffixes, one per line. Each of them is the string of length from $1$ to $n-1$ consisting only of lowercase Latin letters. They can be given in arbitrary order.
It is guaranteed that there are exactly $2$ strings of each length from $1$ to $n-1$. It is also guaranteed that these strings are prefixes and suffixes of some existing string of length $n$.
-----Output-----
Print one string of length $2n-2$ — the string consisting only of characters 'P' and 'S'. The number of characters 'P' should be equal to the number of characters 'S'. The $i$-th character of this string should be 'P' if the $i$-th of the input strings is the prefix and 'S' otherwise.
If there are several possible answers, you can print any.
-----Examples-----
Input
5
ba
a
abab
a
aba
baba
ab
aba
Output
SPPSPSPS
Input
3
a
aa
aa
a
Output
PPSS
Input
2
a
c
Output
PS
-----Note-----
The only string which Ivan can guess in the first example is "ababa".
The only string which Ivan can guess in the second example is "aaa". Answers "SPSP", "SSPP" and "PSPS" are also acceptable.
In the third example Ivan can guess the string "ac" or the string "ca". The answer "SP" is also acceptable.
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())
def test(a, s):
k = [''] * len(a)
d = {}
for i in range(len(a)):
tof = True
if a[i] == s[:len(a[i])]:
if a[i] not in d:
d[a[i]] = 'P'
tof = False
k[i] = 'P'
if not tof:
continue
if a[i] == s[len(s) - len(a[i]):]:
if a[i] not in d or d[a[i]] == 'P':
d[a[i]] = 'S'
tof = False
k[i] = 'S'
if tof:
return [-1]
return k
k = ['', '', '', '']
a = []
for i in range(2 * n - 2):
s = input()
a.append(s)
if len(s) == 1:
if k[0] == '':
k[0] = s
else:
k[1] = s
if len(s) == n - 1:
if k[2] == '':
k[2] = s
else:
k[3] = s
m = k[2] + k[0]
r = test(a, m)
if r != [-1]:
for i in r:
print(i, end='')
return
m = k[2] + k[1]
r = test(a, m)
if r != [-1]:
for i in r:
print(i, end='')
return
m = k[3] + k[0]
r = test(a, m)
if r != [-1]:
for i in r:
print(i, end='')
return
m = k[3] + k[1]
r = test(a, m)
if r != [-1]:
for i in r:
print(i, end='')
``` | vfc_24919 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1092/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\nba\na\nabab\na\naba\nbaba\nab\naba\n",
"output": "SPPSPSPS\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\na\naa\naa\na\n",
"output": "PPSS\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\na\nc\n",
"output": "PS\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\nz\nz\n",
"output": "PS\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\nba\na\nbaba\na\naba\nabab\nab\naba\n",
"output": "SPSSPPPS\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4054 | Solve the following coding problem using the programming language python:
Salve, mi amice.
Et tu quidem de lapis philosophorum. Barba non facit philosophum. Labor omnia vincit. Non potest creatio ex nihilo. Necesse est partibus.
Rp:
I Aqua Fortis
I Aqua Regia
II Amalgama
VII Minium
IV Vitriol
Misce in vitro et æstus, et nil admirari. Festina lente, et nulla tenaci invia est via.
Fac et spera,
Vale,
Nicolas Flamel
-----Input-----
The first line of input contains several space-separated integers a_{i} (0 ≤ a_{i} ≤ 100).
-----Output-----
Print a single integer.
-----Examples-----
Input
2 4 6 8 10
Output
1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
b =[1,1,2,7,4]
a =list(map(int,input().split()))
ans = 100
for i in range(5):
ans = min(a[i]//b[i],ans)
print(ans)
``` | vfc_24923 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/409/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2 4 6 8 10\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4056 | Solve the following coding problem using the programming language python:
You are given an array $a$ consisting of $n$ integers.
Your task is to say the number of such positive integers $x$ such that $x$ divides each number from the array. In other words, you have to find the number of common divisors of all elements in the array.
For example, if the array $a$ will be $[2, 4, 6, 2, 10]$, then $1$ and $2$ divide each number from the array (so the answer for this test is $2$).
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 4 \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 10^{12}$), where $a_i$ is the $i$-th element of $a$.
-----Output-----
Print one integer — the number of such positive integers $x$ such that $x$ divides each number from the given array (in other words, the answer is the number of common divisors of all elements in the array).
-----Examples-----
Input
5
1 2 3 4 5
Output
1
Input
6
6 90 12 18 30 18
Output
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 gcd
n = int(input())
a= list(map(int, input().split()))
k = 0
for i in range(n):
k = gcd(a[i], k)
ans = 0
def fact(n):
nonlocal ans
d = 1
while d* d <= n:
if n % d == 0:
ans += 1
if n // d != d:
ans += 1
d += 1
fact(k)
print(ans)
``` | vfc_24931 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1203/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n1 2 3 4 5\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\n6 90 12 18 30 18\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n385945560000 385945560000\n",
"output": "4200\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n771891120000\n",
"output": "4800\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n167266859760 151104713760 58992373440\n",
"output": "320\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n999999999989\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4057 | Solve the following coding problem using the programming language python:
Polycarp has $n$ coins, the value of the $i$-th coin is $a_i$. Polycarp wants to distribute all the coins between his pockets, but he cannot put two coins with the same value into the same pocket.
For example, if Polycarp has got six coins represented as an array $a = [1, 2, 4, 3, 3, 2]$, he can distribute the coins into two pockets as follows: $[1, 2, 3], [2, 3, 4]$.
Polycarp wants to distribute all the coins with the minimum number of used pockets. Help him to do that.
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 100$) — the number of coins.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 100$) — values of coins.
-----Output-----
Print only one integer — the minimum number of pockets Polycarp needs to distribute all the coins so no two coins with the same value are put into the same pocket.
-----Examples-----
Input
6
1 2 4 3 3 2
Output
2
Input
1
100
Output
1
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 map(int, input().split())
from collections import Counter
n = list(mi())[0]
a = Counter(list(mi()))
ma= -1
for i in a:
if a[i]>ma:
ma = a[i]
print (ma)
``` | vfc_24935 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1003/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6\n1 2 4 3 3 2\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n100\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "100\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100\n",
"output": "100\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "100\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
"output": "100\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "100\n59 47 39 47 47 71 47 28 58 47 35 79 58 47 38 47 47 47 47 27 47 43 29 95 47 49 46 71 47 74 79 47 47 32 45 67 47 47 30 37 47 47 16 67 22 76 47 86 84 10 5 47 47 47 47 47 1 51 47 54 47 8 47 47 9 47 47 47 47 28 47 47 26 47 47 47 47 47 47 92 47 47 77 47 47 24 45 47 10 47 47 89 47 27 47 89 47 67 24 71\n",
"output": "51\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "100\n45 99 10 27 16 85 39 38 17 32 15 23 67 48 50 97 42 70 62 30 44 81 64 73 34 22 46 5 83 52 58 60 33 74 47 88 18 61 78 53 25 95 94 31 3 75 1 57 20 54 59 9 68 7 77 43 21 87 86 24 4 80 11 49 2 72 36 84 71 8 65 55 79 100 41 14 35 89 66 69 93 37 56 82 90 91 51 19 26 92 6 96 13 98 12 28 76 40 63 29\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4058 | Solve the following coding problem using the programming language python:
Vova's house is an array consisting of $n$ elements (yeah, this is the first problem, I think, where someone lives in the array). There are heaters in some positions of the array. The $i$-th element of the array is $1$ if there is a heater in the position $i$, otherwise the $i$-th element of the array is $0$.
Each heater has a value $r$ ($r$ is the same for all heaters). This value means that the heater at the position $pos$ can warm up all the elements in range $[pos - r + 1; pos + r - 1]$.
Vova likes to walk through his house while he thinks, and he hates cold positions of his house. Vova wants to switch some of his heaters on in such a way that each element of his house will be warmed up by at least one heater.
Vova's target is to warm up the whole house (all the elements of the array), i.e. if $n = 6$, $r = 2$ and heaters are at positions $2$ and $5$, then Vova can warm up the whole house if he switches all the heaters in the house on (then the first $3$ elements will be warmed up by the first heater and the last $3$ elements will be warmed up by the second heater).
Initially, all the heaters are off.
But from the other hand, Vova didn't like to pay much for the electricity. So he wants to switch the minimum number of heaters on in such a way that each element of his house is warmed up by at least one heater.
Your task is to find this number of heaters or say that it is impossible to warm up the whole house.
-----Input-----
The first line of the input contains two integers $n$ and $r$ ($1 \le n, r \le 1000$) — the number of elements in the array and the value of heaters.
The second line contains $n$ integers $a_1, a_2, \dots, a_n$ ($0 \le a_i \le 1$) — the Vova's house description.
-----Output-----
Print one integer — the minimum number of heaters needed to warm up the whole house or -1 if it is impossible to do it.
-----Examples-----
Input
6 2
0 1 1 0 0 1
Output
3
Input
5 3
1 0 0 0 1
Output
2
Input
5 10
0 0 0 0 0
Output
-1
Input
10 3
0 0 1 1 0 1 0 0 0 1
Output
3
-----Note-----
In the first example the heater at the position $2$ warms up elements $[1; 3]$, the heater at the position $3$ warms up elements $[2, 4]$ and the heater at the position $6$ warms up elements $[5; 6]$ so the answer is $3$.
In the second example the heater at the position $1$ warms up elements $[1; 3]$ and the heater at the position $5$ warms up elements $[3; 5]$ so the answer is $2$.
In the third example there are no heaters so the answer is -1.
In the fourth example the heater at the position $3$ warms up elements $[1; 5]$, the heater at the position $6$ warms up elements $[4; 8]$ and the heater at the position $10$ warms up elements $[8; 10]$ so the answer is $3$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def mini(arr, n, k):
lo = [0 for i in range(n + 1)]
o = -1
for i in range(n):
if (arr[i] == 1):
o = i
lo[i] = o
a= 0; i = 0
while(i < n):
pos = lo[min(i + k - 1, n - 1)]
if (pos == -1 or pos + k <= i):
return -1
i = pos + k
a+= 1
return a
n,k=list(map(int,input().split()))
arr=[int(i) for i in input().split()]
print(mini(arr, n, k))
``` | vfc_24939 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1066/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6 2\n0 1 1 0 0 1\n",
"output": "3\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4061 | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions is the length of the string.
You are given a string $s$ and a string $t$, both consisting only of lowercase Latin letters. It is guaranteed that $t$ can be obtained from $s$ by removing some (possibly, zero) number of characters (not necessary contiguous) from $s$ without changing order of remaining characters (in other words, it is guaranteed that $t$ is a subsequence of $s$).
For example, the strings "test", "tst", "tt", "et" and "" are subsequences of the string "test". But the strings "tset", "se", "contest" are not subsequences of the string "test".
You want to remove some substring (contiguous subsequence) from $s$ of maximum possible length such that after removing this substring $t$ will remain a subsequence of $s$.
If you want to remove the substring $s[l;r]$ then the string $s$ will be transformed to $s_1 s_2 \dots s_{l-1} s_{r+1} s_{r+2} \dots s_{|s|-1} s_{|s|}$ (where $|s|$ is the length of $s$).
Your task is to find the maximum possible length of the substring you can remove so that $t$ is still a subsequence of $s$.
-----Input-----
The first line of the input contains one string $s$ consisting of at least $1$ and at most $2 \cdot 10^5$ lowercase Latin letters.
The second line of the input contains one string $t$ consisting of at least $1$ and at most $2 \cdot 10^5$ lowercase Latin letters.
It is guaranteed that $t$ is a subsequence of $s$.
-----Output-----
Print one integer — the maximum possible length of the substring you can remove so that $t$ is still a subsequence of $s$.
-----Examples-----
Input
bbaba
bb
Output
3
Input
baaba
ab
Output
2
Input
abcde
abcde
Output
0
Input
asdfasdf
fasd
Output
3
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
s = input()
t = input()
l, r = [0]*len(t), [0]*len(t)
li, ri = 0, len(s) - 1
for i in range(len(t)):
while s[ li ] != t[ i ]:
li += 1
while s[ ri ] != t[ - i - 1 ]:
ri -= 1
l[ i ] = li
r[ -i -1 ] = ri
li += 1
ri -= 1
print( max( [ r[ 0 ], len(s) - l[ -1 ] - 1 ] + [ max( 0, r[ i ] - l[ i - 1 ] ) - 1 for i in range( 1, len(t) ) ] ) )
``` | vfc_24951 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1203/D2",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "bbaba\nbb\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "baaba\nab\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "abcde\nabcde\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "asdfasdf\nfasd\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "zywmerhahxlqsjekpqsdqxnjiduyjrytswiweohctztgpiorwimhjmdfofqynyggcrtzslbyvkuvqrsgwyacyvcuathplliwwshusluiqwuhutnzwvuchfedhwwfdzizltdxibtsaocpnqezstblgkfdcvfsjjyzwalkksumsaljqljmmkcyejwwdkolmcgmodoiclte\nzywmehahxlqjekqsdqjidytswwztgiowimhmffqygctzslbykurwacyvcuaplwshsluiqwuhutnwchfewwfdizttcpnqestgkfvsjylkksumaljmmkcjwwdkolmcgodcle\n",
"output": "5\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "nqlswpkupyawfzygzjfntqpivmudprpmtkhwjcoabkkxfemjekxvnjikbvtbzgrxyacflvausuwgqfxvfcgxphzeiwpitswykvcsyspvimmynlyeldkqjsogjhszcqtvteiefdcissquzeynmjdhazcygrypyzjhjhsntegsuryjgpknwvnjxplztmjszidqkihuxgzc\nnlwkupywfzgzftqpiudprmkhwcozenmjdhacygryjhhntgugpkwvnjxplztszikihgc\n",
"output": "101\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4064 | Solve the following coding problem using the programming language python:
Vova had a pretty weird sleeping schedule. There are $h$ hours in a day. Vova will sleep exactly $n$ times. The $i$-th time he will sleep exactly after $a_i$ hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is $0$). Each time Vova sleeps exactly one day (in other words, $h$ hours).
Vova thinks that the $i$-th sleeping time is good if he starts to sleep between hours $l$ and $r$ inclusive.
Vova can control himself and before the $i$-th time can choose between two options: go to sleep after $a_i$ hours or after $a_i - 1$ hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
-----Input-----
The first line of the input contains four integers $n, h, l$ and $r$ ($1 \le n \le 2000, 3 \le h \le 2000, 0 \le l \le r < h$) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i < h$), where $a_i$ is the number of hours after which Vova goes to sleep the $i$-th time.
-----Output-----
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
-----Example-----
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
-----Note-----
The maximum number of good times in the example is $3$.
The story starts from $t=0$. Then Vova goes to sleep after $a_1 - 1$ hours, now the time is $15$. This time is not good. Then Vova goes to sleep after $a_2 - 1$ hours, now the time is $15 + 16 = 7$. This time is also not good. Then Vova goes to sleep after $a_3$ hours, now the time is $7 + 14 = 21$. This time is good. Then Vova goes to sleep after $a_4 - 1$ hours, now the time is $21 + 19 = 16$. This time is not good. Then Vova goes to sleep after $a_5$ hours, now the time is $16 + 20 = 12$. This time is not good. Then Vova goes to sleep after $a_6$ hours, now the time is $12 + 11 = 23$. This time is good. Then Vova goes to sleep after $a_7$ hours, now the time is $23 + 22 = 21$. This time is also good.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def main():
import sys
input = sys.stdin.readline
N, H, L, R = list(map(int, input().split()))
A = list(map(int, input().split()))
dp = [[-1] * H for _ in range(N+1)]
dp[0][0] = 0
for i, a in enumerate(A):
for t in range(H):
if dp[i][t] >= 0:
dp[i+1][(t+a)%H] = max(dp[i+1][(t+a)%H], dp[i][t] + int(L <= (t+a)%H <= R))
dp[i + 1][(t + a-1) % H] = max(dp[i + 1][(t + a-1) % H], dp[i][t] + int(L <= (t + a-1) % H <= R))
print(max(dp[-1]))
def __starting_point():
main()
__starting_point()
``` | vfc_24963 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1324/E",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "7 24 21 23\n16 17 14 20 20 11 22\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "65 654 560 571\n83 511 615 263 171 146 241 511 582 216 352 632 506 538 536 217 627 213 324 579 172 241 363 584 450 144 447 536 241 523 162 21 437 291 191 111 567 502 170 570 231 493 169 360 107 114 322 160 574 611 460 558 616 361 284 58 41 345 450 560 543 520 105 416 38\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 24 21 22\n23 1\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 3 0 0\n1 1 1 1 1\n",
"output": "5\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4065 | Solve the following coding problem using the programming language python:
You are given a problemset consisting of $n$ problems. The difficulty of the $i$-th problem is $a_i$. It is guaranteed that all difficulties are distinct and are given in the increasing order.
You have to assemble the contest which consists of some problems of the given problemset. In other words, the contest you have to assemble should be a subset of problems (not necessary consecutive) of the given problemset. There is only one condition that should be satisfied: for each problem but the hardest one (the problem with the maximum difficulty) there should be a problem with the difficulty greater than the difficulty of this problem but not greater than twice the difficulty of this problem. In other words, let $a_{i_1}, a_{i_2}, \dots, a_{i_p}$ be the difficulties of the selected problems in increasing order. Then for each $j$ from $1$ to $p-1$ $a_{i_{j + 1}} \le a_{i_j} \cdot 2$ should hold. It means that the contest consisting of only one problem is always valid.
Among all contests satisfying the condition above you have to assemble one with the maximum number of problems. Your task is to find this number of problems.
-----Input-----
The first line of the input contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the number of problems in the problemset.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^9$) — difficulties of the problems. It is guaranteed that difficulties of the problems are distinct and are given in the increasing order.
-----Output-----
Print a single integer — maximum number of problems in the contest satisfying the condition in the problem statement.
-----Examples-----
Input
10
1 2 5 6 7 10 21 23 24 49
Output
4
Input
5
2 10 50 110 250
Output
1
Input
6
4 7 12 100 150 199
Output
3
-----Note-----
Description of the first example: there are $10$ valid contests consisting of $1$ problem, $10$ valid contests consisting of $2$ problems ($[1, 2], [5, 6], [5, 7], [5, 10], [6, 7], [6, 10], [7, 10], [21, 23], [21, 24], [23, 24]$), $5$ valid contests consisting of $3$ problems ($[5, 6, 7], [5, 6, 10], [5, 7, 10], [6, 7, 10], [21, 23, 24]$) and a single valid contest consisting of $4$ problems ($[5, 6, 7, 10]$).
In the second example all the valid contests consist of $1$ problem.
In the third example are two contests consisting of $3$ problems: $[4, 7, 12]$ and $[100, 150, 199]$.
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()))
ans = [1]
t = 1
for i in range(n - 1):
if a[i + 1] / a[i] <= 2:
t += 1
else:
t = 1
ans.append(t)
print(max(ans))
``` | vfc_24967 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1029/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "10\n1 2 5 6 7 10 21 23 24 49\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n2 10 50 110 250\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\n4 7 12 100 150 199\n",
"output": "3\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4066 | 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$.
Your problem is to find such pair of indices $i, j$ ($1 \le i < j \le n$) that $lcm(a_i, a_j)$ is minimum possible.
$lcm(x, y)$ is the least common multiple of $x$ and $y$ (minimum positive number such that both $x$ and $y$ are divisors of this number).
-----Input-----
The first line of the input contains one integer $n$ ($2 \le n \le 10^6$) — 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 10^7$), where $a_i$ is the $i$-th element of $a$.
-----Output-----
Print two integers $i$ and $j$ ($1 \le i < j \le n$) such that the value of $lcm(a_i, a_j)$ is minimum among all valid pairs $i, j$. If there are multiple answers, you can print any.
-----Examples-----
Input
5
2 4 8 3 6
Output
1 2
Input
5
5 2 11 3 7
Output
2 4
Input
6
2 5 10 1 10 2
Output
1 4
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import math
from collections import defaultdict
import sys
input = sys.stdin.readline
def main():
n = int(input())
a = list(map(int, input().split()))
MAX = 10**7 + 1
res = MAX * MAX
#MAX_P = int(math.sqrt(MAX))
MAX_P = 3163
primes = []
p = 2
sieve = [True] * (MAX_P+1)
while p < MAX_P:
if sieve[p]:
primes.append(p)
k = 2
while k * p < MAX_P:
sieve[k * p] = False
k += 1
p += 1
np = len(primes)
cand1 = {}
cand2 = {}
ind1 = {}
ind2 = {}
res = MAX * MAX
for index in range(n):
val = a[index]
if val >= res:
continue
divisors = [1]
p = 0
while val > 0 and p < np:
while val % primes[p] == 0:
divisors += [d * primes[p] for d in divisors]
val //= primes[p]
p += 1
if val > 1:
divisors += [d * val for d in divisors]
for d in set(divisors):
if d not in cand1:
cand1[d] = a[index]
ind1[d] = index
else:
if d not in cand2:
if a[index] < cand1[d]:
cand2[d] = cand1[d]
ind2[d] = ind1[d]
cand1[d] = a[index]
ind1[d] = index
else:
cand2[d] = a[index]
ind2[d] = index
else:
if a[index] < cand1[d]:
cand2[d] = cand1[d]
ind2[d] = ind1[d]
cand1[d] = a[index]
ind1[d] = index
elif a[index] < cand2[d]:
cand2[d] = a[index]
ind2[d] = index
else:
continue
if res > cand1[d] // d * cand2[d]:
x, y = ind1[d], ind2[d]
res = cand1[d] // d * cand2[d]
print(min(x+1, y+1), max(x+1, y+1))
def __starting_point():
main()
__starting_point()
``` | vfc_24971 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1154/G",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n2 4 8 3 6\n",
"output": "1 2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n5 2 11 3 7\n",
"output": "2 4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\n2 5 10 1 10 2\n",
"output": "1 4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1 1\n",
"output": "1 2\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4067 | Solve the following coding problem using the programming language python:
You are given a string $s$ consisting of exactly $n$ characters, and each character is either '0', '1' or '2'. Such strings are called ternary strings.
Your task is to replace minimum number of characters in this string with other characters to obtain a balanced ternary string (balanced ternary string is a ternary string such that the number of characters '0' in this string is equal to the number of characters '1', and the number of characters '1' (and '0' obviously) is equal to the number of characters '2').
Among all possible balanced ternary strings you have to obtain the lexicographically (alphabetically) smallest.
Note that you can neither remove characters from the string nor add characters to the string. Also note that you can replace the given characters only with characters '0', '1' and '2'.
It is guaranteed that the answer exists.
-----Input-----
The first line of the input contains one integer $n$ ($3 \le n \le 3 \cdot 10^5$, $n$ is divisible by $3$) — the number of characters in $s$.
The second line contains the string $s$ consisting of exactly $n$ characters '0', '1' and '2'.
-----Output-----
Print one string — the lexicographically (alphabetically) smallest balanced ternary string which can be obtained from the given one with minimum number of replacements.
Because $n$ is divisible by $3$ it is obvious that the answer exists. And it is obvious that there is only one possible answer.
-----Examples-----
Input
3
121
Output
021
Input
6
000000
Output
001122
Input
6
211200
Output
211200
Input
6
120110
Output
120120
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
from math import sin, tan, cos, pi, atan2, sqrt, acos, atan, factorial
from random import randint
n = int(stdin.readline())
s = list(stdin.readline().strip())
a, b, c = s.count('0'), s.count('1'), s.count('2')
d = n // 3
for i in range(len(s)):
if s[i] == '2' and c > d:
if a < d:
s[i] = '0'
a += 1
c -= 1
else:
s[i] = '1'
b += 1
c -= 1
elif s[i] == '1' and b > d:
if a < d:
s[i] = '0'
a += 1
b -= 1
for i in range(len(s) - 1, -1, -1):
if s[i] == '1' and b > d:
if c < d:
s[i] = '2'
b -= 1
c += 1
elif s[i] == '0' and a > d:
if c < d:
s[i] = '2'
a -= 1
c += 1
elif b < d:
s[i] = '1'
a -= 1
b += 1
stdout.write(''.join(s))
``` | vfc_24975 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1102/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n121\n",
"output": "021\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\n000000\n",
"output": "001122\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\n211200\n",
"output": "211200\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4070 | Solve the following coding problem using the programming language python:
Programmers' kids solve this riddle in 5-10 minutes. How fast can you do it?
-----Input-----
The input contains a single integer n (0 ≤ n ≤ 2000000000).
-----Output-----
Output a single integer.
-----Examples-----
Input
11
Output
2
Input
14
Output
0
Input
61441
Output
2
Input
571576
Output
10
Input
2128506
Output
3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
TASK = "stars"
# FIN = open(TASK + ".in")
# FOUT = open(TASK + ".out", "w")
a = [1, 0, 0, 0, 1, 0, 1, 0, 2, 1, 1, 2, 0, 1, 0, 0]
ans = 0
n = int(input())
if n == 0:
print(1)
return
while (n > 0):
tmp = n % 16
ans += a[tmp]
n //= 16
print(ans)
# FIN.close()
# FOUT.close()
``` | vfc_24987 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/784/B",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "11\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "14\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "61441\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "571576\n",
"output": "10\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2128506\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "0\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4071 | Solve the following coding problem using the programming language python:
-----Input-----
The input contains a single integer a (1 ≤ a ≤ 30).
-----Output-----
Output a single integer.
-----Example-----
Input
3
Output
27
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
a = [ 4, 22, 27, 58, 85, 94, 121, 166, 202, 265, 274, 319, 346, 355, 378, 382, 391, 438, 454, 483, 517, 526, 535, 562, 576, 588, 627, 634, 636, 645]
print(a[int(input()) - 1])
``` | vfc_24991 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/784/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n",
"output": "27\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n",
"output": "22\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n",
"output": "58\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n",
"output": "85\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\n",
"output": "94\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4072 | Solve the following coding problem using the programming language python:
-----Input-----
The input contains a single integer a (10 ≤ a ≤ 999).
-----Output-----
Output 0 or 1.
-----Examples-----
Input
13
Output
1
Input
927
Output
1
Input
48
Output
0
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
x = int(input())
print(x%2)
``` | vfc_24995 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/952/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "13\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "927\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "48\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n",
"output": "0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4073 | Solve the following coding problem using the programming language python:
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
-----Input-----
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers a_{i} (1 ≤ a_{i} ≤ 11).
-----Output-----
Output a single integer.
-----Example-----
Input
4
2 5 3 1
Output
4
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()))
print(max(a) ^ a[-1])
``` | vfc_24999 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/784/C",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n2 5 3 1\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1 5\n",
"output": "0\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4074 | Solve the following coding problem using the programming language python:
Polycarp wants to buy exactly $n$ shovels. The shop sells packages with shovels. The store has $k$ types of packages: the package of the $i$-th type consists of exactly $i$ shovels ($1 \le i \le k$). The store has an infinite number of packages of each type.
Polycarp wants to choose one type of packages and then buy several (one or more) packages of this type. What is the smallest number of packages Polycarp will have to buy to get exactly $n$ shovels?
For example, if $n=8$ and $k=7$, then Polycarp will buy $2$ packages of $4$ shovels.
Help Polycarp find the minimum number of packages that he needs to buy, given that he: will buy exactly $n$ shovels in total; the sizes of all packages he will buy are all the same and the number of shovels in each package is an integer from $1$ to $k$, inclusive.
-----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, one per line.
Each test case consists of two positive integers $n$ ($1 \le n \le 10^9$) and $k$ ($1 \le k \le 10^9$) — the number of shovels and the number of types of packages.
-----Output-----
Print $t$ answers to the test cases. Each answer is a positive integer — the minimum number of packages.
-----Example-----
Input
5
8 7
8 1
6 10
999999733 999999732
999999733 999999733
Output
2
8
1
999999733
1
-----Note-----
The answer to the first test case was explained in the statement.
In the second test case, there is only one way to buy $8$ shovels — $8$ packages of one shovel.
In the third test case, you need to buy a $1$ package of $6$ shovels.
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, k = read_ints()
i = 1
largest = 1
while i * i <= n:
if n % i == 0:
if i <= k:
largest = max(largest, i)
if n // i <= k:
largest = max(largest, n // i)
i += 1
print(n // largest)
``` | vfc_25003 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1360/D",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n8 7\n8 1\n6 10\n999999733 999999732\n999999733 999999733\n",
"output": "2\n8\n1\n999999733\n1\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4077 | Solve the following coding problem using the programming language python:
You are given an integer sequence $a_1, a_2, \dots, a_n$.
Find the number of pairs of indices $(l, r)$ ($1 \le l \le r \le n$) such that the value of median of $a_l, a_{l+1}, \dots, a_r$ is exactly the given number $m$.
The median of a sequence is the value of an element which is in the middle of the sequence after sorting it in non-decreasing order. If the length of the sequence is even, the left of two middle elements is used.
For example, if $a=[4, 2, 7, 5]$ then its median is $4$ since after sorting the sequence, it will look like $[2, 4, 5, 7]$ and the left of two middle elements is equal to $4$. The median of $[7, 1, 2, 9, 6]$ equals $6$ since after sorting, the value $6$ will be in the middle of the sequence.
Write a program to find the number of pairs of indices $(l, r)$ ($1 \le l \le r \le n$) such that the value of median of $a_l, a_{l+1}, \dots, a_r$ is exactly the given number $m$.
-----Input-----
The first line contains integers $n$ and $m$ ($1 \le n,m \le 2\cdot10^5$) — the length of the given sequence and the required value of the median.
The second line contains an integer sequence $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 2\cdot10^5$).
-----Output-----
Print the required number.
-----Examples-----
Input
5 4
1 4 5 60 4
Output
8
Input
3 1
1 1 1
Output
6
Input
15 2
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3
Output
97
-----Note-----
In the first example, the suitable pairs of indices are: $(1, 3)$, $(1, 4)$, $(1, 5)$, $(2, 2)$, $(2, 3)$, $(2, 5)$, $(4, 5)$ and $(5, 5)$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
MAXN = 200001
def less_sum(s, m):
n = len(s)
a = 0
b = 0
res = 0
last = 0
count = [0 for i in range(-MAXN, MAXN+1)]
count[0] = 1
x = 0
last = 1
for i in range(n):
if s[i] > m:
b += 1
else:
a += 1
x = a-b
#print(x)
#print(count[-2], count[-1], count[0], count[1], count[2])
if s[i] > m:
last -= count[x+1]
else:
last += count[x]
#print(x, last)
res += last
count[x] += 1
last += 1
#print(res)
return res
n, m = map(int, input().split(' '))
s = list(map(int, input().split(' ')))[0:n]
#print(m, s)
print(less_sum(s, m) - less_sum(s, m-1))
``` | vfc_25015 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1005/E2",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5 4\n1 4 5 60 4\n",
"output": "8\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 1\n1 1 1\n",
"output": "6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "15 2\n1 2 3 1 2 3 1 2 3 1 2 3 1 2 3\n",
"output": "97\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 1\n1\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 1\n1 2\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 1\n2 1\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4078 | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions is a number of elements in the array.
You are given an array $a$ consisting of $n$ integers. The value of the $i$-th element of the array is $a_i$.
You are also given a set of $m$ segments. The $j$-th segment is $[l_j; r_j]$, where $1 \le l_j \le r_j \le n$.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array $a = [0, 0, 0, 0, 0]$ and the given segments are $[1; 3]$ and $[2; 4]$ then you can choose both of them and the array will become $b = [-1, -2, -2, -1, 0]$.
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array $a$ and obtain the array $b$ then the value $\max\limits_{i=1}^{n}b_i - \min\limits_{i=1}^{n}b_i$ will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
-----Input-----
The first line of the input contains two integers $n$ and $m$ ($1 \le n \le 300, 0 \le m \le 300$) — the length of the array $a$ and the number of segments, respectively.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($-10^6 \le a_i \le 10^6$), where $a_i$ is the value of the $i$-th element of the array $a$.
The next $m$ lines are contain two integers each. The $j$-th of them contains two integers $l_j$ and $r_j$ ($1 \le l_j \le r_j \le n$), where $l_j$ and $r_j$ are the ends of the $j$-th segment.
-----Output-----
In the first line of the output print one integer $d$ — the maximum possible value $\max\limits_{i=1}^{n}b_i - \min\limits_{i=1}^{n}b_i$ if $b$ is the array obtained by applying some subset of the given segments to the array $a$.
In the second line of the output print one integer $q$ ($0 \le q \le m$) — the number of segments you apply.
In the third line print $q$ distinct integers $c_1, c_2, \dots, c_q$ in any order ($1 \le c_k \le m$) — indices of segments you apply to the array $a$ in such a way that the value $\max\limits_{i=1}^{n}b_i - \min\limits_{i=1}^{n}b_i$ of the obtained array $b$ is maximum possible.
If there are multiple answers, you can print any.
-----Examples-----
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
-----Note-----
In the first example the obtained array $b$ will be $[0, -4, 1, 1, 2]$ so the answer is $6$.
In the second example the obtained array $b$ will be $[2, -3, 1, -1, 4]$ so the answer is $7$.
In the third example you cannot do anything so 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 copy import deepcopy
n,m = map(int,input().split())
a = list(map(int,input().split()))
b = [list(map(int,input().split())) for i in range(m)]
best1 = -1
best2 = -1
best3 = []
for i in range(n):
tmp = 0
tmp2 = 0
tmp3 = []
c = deepcopy(a)
for j in range(m):
x,y = b[j]
x-=1;y-=1
if x<= i and i <= y:
continue
for k in range(x,y+1):
c[k] -= 1
tmp3.append(j+1)
tmp2 += 1
kon = max(c)-min(c)
if best1 < kon:
best1 = kon
best2 = tmp2
best3 = tmp3
print(best1)
print(best2)
print(*best3)
``` | vfc_25019 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1108/E1",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5 4\n2 -2 3 1 2\n1 3\n4 5\n2 5\n1 3\n",
"output": "6\n2\n4 1 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 4\n2 -2 3 1 4\n3 5\n3 4\n2 4\n2 5\n",
"output": "7\n2\n2 3 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 0\n1000000\n",
"output": "0\n0\n\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 0\n-1\n",
"output": "0\n0\n\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 1\n-10\n1 1\n",
"output": "0\n0\n\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4079 | Solve the following coding problem using the programming language python:
A string is called diverse if it contains consecutive (adjacent) letters of the Latin alphabet and each letter occurs exactly once. For example, the following strings are diverse: "fced", "xyz", "r" and "dabcef". The following string are not diverse: "az", "aa", "bad" and "babc". Note that the letters 'a' and 'z' are not adjacent.
Formally, consider positions of all letters in the string in the alphabet. These positions should form contiguous segment, i.e. they should come one by one without any gaps. And all letters in the string should be distinct (duplicates are not allowed).
You are given a sequence of strings. For each string, if it is diverse, print "Yes". Otherwise, print "No".
-----Input-----
The first line contains integer $n$ ($1 \le n \le 100$), denoting the number of strings to process. The following $n$ lines contains strings, one string per line. Each string contains only lowercase Latin letters, its length is between $1$ and $100$, inclusive.
-----Output-----
Print $n$ lines, one line per a string in the input. The line should contain "Yes" if the corresponding string is diverse and "No" if the corresponding string is not diverse. You can print each letter in any case (upper or lower). For example, "YeS", "no" and "yES" are all acceptable.
-----Example-----
Input
8
fced
xyz
r
dabcef
az
aa
bad
babc
Output
Yes
Yes
Yes
Yes
No
No
No
No
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):
s = input()
if len(s) == len(set(s)) and abs(ord(min(s)) - ord(max(s))) == len(s) - 1:
print('Yes')
else:
print('No')
``` | vfc_25023 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1144/A",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "8\nfced\nxyz\nr\ndabcef\naz\naa\nbad\nbabc\n",
"output": "Yes\nYes\nYes\nYes\nNo\nNo\nNo\nNo\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "44\nops\ntest\nyes\nno\nac\nbc\ncb\nz\na\nq\nr\nu\nqq\nop\npo\nxu\nux\nxy\nyx\na\nab\nabc\nabcd\nabcde\nabcdef\nabcdefg\nbcdefg\ncdefg\ndefg\nefgd\nefef\nabacaba\nabz\naoi\nioi\ncodeforces\nklmn\nnmlk\nkln\nklmnl\nkmn\nkklmn\nklmnn\naklkmn\n",
"output": "No\nNo\nNo\nYes\nNo\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nNo\nYes\nYes\nNo\nNo\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nNo\nNo\nNo\nNo\nNo\nNo\nYes\nYes\nNo\nNo\nNo\nNo\nNo\nNo\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\nf\n",
"output": "Yes\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\nshohrukh\n",
"output": "No\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "69\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\n",
"output": "Yes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\nYes\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\nshohruk\n",
"output": "No\n",
"type": "stdin_stdout"
}
]
} |
apps | verifiable_code | 4080 | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions is a number of elements in the array.
You are given an array $a$ consisting of $n$ integers. The value of the $i$-th element of the array is $a_i$.
You are also given a set of $m$ segments. The $j$-th segment is $[l_j; r_j]$, where $1 \le l_j \le r_j \le n$.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array $a = [0, 0, 0, 0, 0]$ and the given segments are $[1; 3]$ and $[2; 4]$ then you can choose both of them and the array will become $b = [-1, -2, -2, -1, 0]$.
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array $a$ and obtain the array $b$ then the value $\max\limits_{i=1}^{n}b_i - \min\limits_{i=1}^{n}b_i$ will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
-----Input-----
The first line of the input contains two integers $n$ and $m$ ($1 \le n \le 10^5, 0 \le m \le 300$) — the length of the array $a$ and the number of segments, respectively.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($-10^6 \le a_i \le 10^6$), where $a_i$ is the value of the $i$-th element of the array $a$.
The next $m$ lines are contain two integers each. The $j$-th of them contains two integers $l_j$ and $r_j$ ($1 \le l_j \le r_j \le n$), where $l_j$ and $r_j$ are the ends of the $j$-th segment.
-----Output-----
In the first line of the output print one integer $d$ — the maximum possible value $\max\limits_{i=1}^{n}b_i - \min\limits_{i=1}^{n}b_i$ if $b$ is the array obtained by applying some subset of the given segments to the array $a$.
In the second line of the output print one integer $q$ ($0 \le q \le m$) — the number of segments you apply.
In the third line print $q$ distinct integers $c_1, c_2, \dots, c_q$ in any order ($1 \le c_k \le m$) — indices of segments you apply to the array $a$ in such a way that the value $\max\limits_{i=1}^{n}b_i - \min\limits_{i=1}^{n}b_i$ of the obtained array $b$ is maximum possible.
If there are multiple answers, you can print any.
-----Examples-----
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
4 1
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
-----Note-----
In the first example the obtained array $b$ will be $[0, -4, 1, 1, 2]$ so the answer is $6$.
In the second example the obtained array $b$ will be $[2, -3, 1, -1, 4]$ so the answer is $7$.
In the third example you cannot do anything so 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
import sys
# a very nice implementation of a minimum segment tree with
# some inspiration taken from https://codeforces.com/blog/entry/18051
# this implementation should be able to be modified to do pretty
# much anything one would want to do with segment trees apart from
# persistance.
# note that especially in python this implementation is much much better
# than most other approches because how slow python can be with function
# calls.
# currently it allows for two operations, both running in o(log n),
# 'add(l,r,value)' adds value to [l,r)
# 'find_min(l,r)' finds the index with the smallest value
class super_seg:
def __init__(self,data):
n = len(data)
m = 1
while m<n: m *= 2
self.n = n
self.m = m
self.data = [0]*(2*m)
for i in range(n):
self.data[i+m] = data[i]
for i in reversed(range(m)):
self.data[i] = min(self.data[2*i], self.data[2*i+1])
self.query = [0]*(2*m)
# push the query on seg_ind to its children
def push(self,seg_ind):
# let the children know of the queries
q = self.query[seg_ind]
self.query[2*seg_ind] += q
self.query[2*seg_ind+1] += q
self.data[2*seg_ind] += q
self.data[2*seg_ind+1] += q
# remove queries from seg_ind
self.data[seg_ind] = min(self.data[2*seg_ind],self.data[2*seg_ind+1])
self.query[seg_ind] = 0
# updates the node seg_ind to know of all queries
# applied to it via its ancestors
def update(self,seg_ind):
# find all indecies to be updated
seg_ind //= 2
inds = []
while seg_ind>0:
inds.append(seg_ind)
seg_ind//=2
# push the queries down the segment tree
for ind in reversed(inds):
self.push(ind)
# make the changes to seg_ind be known to its ancestors
def build(self,seg_ind):
seg_ind//=2
while seg_ind>0:
self.data[seg_ind] = min(self.data[2*seg_ind], self.data[2*seg_ind+1]) + self.query[seg_ind]
seg_ind //= 2
# lazily add value to [l,r)
def add(self,l,r,value):
l += self.m
r += self.m
l0 = l
r0 = r
while l<r:
if l%2==1:
self.query[l]+= value
self.data[l] += value
l+=1
if r%2==1:
r-=1
self.query[r]+= value
self.data[r] += value
l//=2
r//=2
# tell all nodes above of the updated
# area of the updates
self.build(l0)
self.build(r0-1)
# min of data[l,r)
def min(self,l,r):
l += self.m
r += self.m
# apply all the lazily stored queries
self.update(l)
self.update(r-1)
segs = []
while l<r:
if l%2==1:
segs.append(l)
l+=1
if r%2==1:
r-=1
segs.append(r)
l//=2
r//=2
return min(self.data[ind] for ind in segs)
# find index of smallest value in data[l,r)
def find_min(self,l,r):
l += self.m
r += self.m
# apply all the lazily stored queries
self.update(l)
self.update(r-1)
segs = []
while l<r:
if l%2==1:
segs.append(l)
l+=1
if r%2==1:
r-=1
segs.append(r)
l//=2
r//=2
ind = min(segs, key=lambda i:self.data[i])
mini = self.data[ind]
# dig down in search of mini
while ind<self.m:
self.push(ind)
if self.data[2*ind]==mini:
ind *= 2
else:
ind = 2*ind+1
return ind-self.m,mini
n,m = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
inter = []
inter2 = []
for _ in range(m):
l,r = [int(x) for x in input().split()]
l -= 1
inter.append((l,r))
inter2.append((r,l))
inter_copy = inter[:]
inter.sort()
inter2.sort()
Aneg = super_seg([-a for a in A])
besta = -1
besta_ind = -1
j1 = 0
j2 = 0
for i in range(n):
# Only segments containing i should be active
# Activate
while j1<m and inter[j1][0]<=i:
l,r = inter[j1]
Aneg.add(l,r,1)
j1 += 1
# Deactivate
while j2<m and inter2[j2][0]<=i:
r,l = inter2[j2]
Aneg.add(l,r,-1)
j2 += 1
Amax = -Aneg.min(0,n)
Ai = -Aneg.min(i,i+1)
if Amax-Ai>besta:
besta = Amax-Ai
besta_ind = i
ints = [j for j in range(m) if inter_copy[j][0]<=besta_ind<inter_copy[j][1]]
print(besta)
print(len(ints))
print(*[x+1 for x in ints])
``` | vfc_25027 | {
"difficulty": "introductory",
"memory_limit": null,
"memory_limit_bytes": null,
"problem_url": "https://codeforces.com/problemset/problem/1108/E2",
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5 4\n2 -2 3 1 2\n1 3\n4 5\n2 5\n1 3\n",
"output": "6\n2\n1 4 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 4\n2 -2 3 1 4\n3 5\n3 4\n2 4\n2 5\n",
"output": "7\n2\n2 3 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 0\n1000000\n",
"output": "0\n0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 0\n-1\n",
"output": "0\n0\n",
"type": "stdin_stdout"
}
]
} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.