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 |
|---|---|---|---|---|---|---|---|
code_contests | verifiable_code | seavote | Solve the following coding problem using the programming language python:
Sereja conducted a voting about N of his opinions. Ai percent of people voted for opinion number i.
This statistics is called valid if sum of all Ai is equal to 100.
Now let us define rounding up of a statistics A.
If Ai is not an integer, it will be rounded up to next integer.
Otherwise it will be left as it is.
e.g. 4.1 became 5, 4.9 became 5 but 6 will still be 6.
Now let us consider a statistics B of size N in which each of Bi is an integer. Now he wants to know whether there exists some valid statistic A of size N (may contain real numbers) such that after rounding it up, it becomes same as B?
Input
First line of input contain integer T - number of test cases.
For each test, case first line contains integer N - number of opinions.
Next line contains N integers B1, B2, ..., BN as defined in the problem.
Output
For each test case, output YES or NO denoting the answer of the problem, i.e. if there exists some statistics A which could be rounded to make it B, print YES otherwise NO.
Constraints
1 β€ T β€ 50
1 β€ N β€ 10000
0 β€ Bi β€ 1000
Sub tasks
Example
Input:
3
3
30 30 30
4
25 25 25 25
2
50 51
Output:
NO
YES
YES
Explanation
In test case 1, There can not be any A which could be rounded up to get B. Hence answer is NO.
In test case 2, In this case A = {25, 25, 25, 25}. After rounding we get {25, 25, 25, 25} which is equal to B. Hence answer is YES.
In test case 3, A = {49.5, 50.5}. After rounding up we get {50, 51} which is equal to B. Hence answer is YES.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
from pprint import pprint as pp
def GI(): return int(raw_input())
def GIS(): return map(int, raw_input().split())
def main():
T = GI()
for t in xrange(T):
N = GI()
B = GIS()
excess = sum(B) - 100
if excess < 0:
print 'NO'
elif excess < N - B.count(0):
print 'YES'
else:
print 'NO'
main()
``` | vfc_33805 | {
"difficulty": "3",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n3\n30 30 30\n4\n25 25 25 25\n2\n50 51",
"output": "NO\nYES\nYES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n3\n30 30 30\n4\n25 40 25 25\n2\n50 51",
"output": "NO\nNO\nYES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n3\n30 15 30\n4\n25 25 25 25\n2\n50 51",
"output": "NO\nYES\nYES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n3\n30 30 30\n4\n25 40 25 25\n2\n50 36",
"output": "NO\nNO\nNO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n3\n30 30 30\n4\n25 25 25 25\n2\n31 51",
"output": "NO\nYES\nNO\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1003_C. Intense Heat | Solve the following coding problem using the programming language python:
The heat during the last few days has been really intense. Scientists from all over the Berland study how the temperatures and weather change, and they claim that this summer is abnormally hot. But any scientific claim sounds a lot more reasonable if there are some numbers involved, so they have decided to actually calculate some value which would represent how high the temperatures are.
Mathematicians of Berland State University came up with a special heat intensity value. This value is calculated as follows:
Suppose we want to analyze the segment of n consecutive days. We have measured the temperatures during these n days; the temperature during i-th day equals a_i.
We denote the average temperature of a segment of some consecutive days as the arithmetic mean of the temperature measures during this segment of days. So, if we want to analyze the average temperature from day x to day y, we calculate it as \frac{β _{i = x}^{y} a_i}{y - x + 1} (note that division is performed without any rounding). The heat intensity value is the maximum of average temperatures over all segments of not less than k consecutive days. For example, if analyzing the measures [3, 4, 1, 2] and k = 3, we are interested in segments [3, 4, 1], [4, 1, 2] and [3, 4, 1, 2] (we want to find the maximum value of average temperature over these segments).
You have been hired by Berland State University to write a program that would compute the heat intensity value of a given period of days. Are you up to this task?
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 5000) β the number of days in the given period, and the minimum number of days in a segment we consider when calculating heat intensity value, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 5000) β the temperature measures during given n days.
Output
Print one real number β the heat intensity value, i. e., the maximum of average temperatures over all segments of not less than k consecutive days.
Your answer will be considered correct if the following condition holds: |res - res_0| < 10^{-6}, where res is your answer, and res_0 is the answer given by the jury's solution.
Example
Input
4 3
3 4 1 2
Output
2.666666666666667
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
n, k = map(int, input().split())
ar = list(map(int, input().split()))
average = M = 0
for i in range(n):
s = 0
for j in range(i,n):
s += ar[j]
if (j-i+1) >= k:
average = s / (j-i+1)
M = max(M, average)
print(M)
``` | vfc_33809 | {
"difficulty": "9",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 4, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 3\n3 4 1 2\n",
"output": "2.666666666666667",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 5\n4 6 6 6 2\n",
"output": "4.8",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 1\n3 10 9 10 6\n",
"output": "10",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 2\n2 1 2\n",
"output": "1.666666666666667",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 2\n7 3 3 1 8\n",
"output": "5",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 4\n5 1 10 6 1\n",
"output": "5.5",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1046_C. Space Formula | Solve the following coding problem using the programming language python:
Formula 1 officials decided to introduce new competition. Cars are replaced by space ships and number of points awarded can differ per race.
Given the current ranking in the competition and points distribution for the next race, your task is to calculate the best possible ranking for a given astronaut after the next race. It's guaranteed that given astronaut will have unique number of points before the race.
Input
The first line contains two integer numbers N (1 β€ N β€ 200000) representing number of F1 astronauts, and current position of astronaut D (1 β€ D β€ N) you want to calculate best ranking for (no other competitor will have the same number of points before the race).
The second line contains N integer numbers S_k (0 β€ S_k β€ 10^8, k=1...N), separated by a single space, representing current ranking of astronauts. Points are sorted in non-increasing order.
The third line contains N integer numbers P_k (0 β€ P_k β€ 10^8, k=1...N), separated by a single space, representing point awards for the next race. Points are sorted in non-increasing order, so winner of the race gets the maximum number of points.
Output
Output contains one integer number β the best possible ranking for astronaut after the race. If multiple astronauts have the same score after the race, they all share the best ranking.
Example
Input
4 3
50 30 20 10
15 10 7 3
Output
2
Note
If the third ranked astronaut wins the race, he will have 35 points. He cannot take the leading position, but he can overtake the second position if the second ranked astronaut finishes the race at the last position.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
n,k=map(int,input().strip().split())
cr = list(map(int,input().strip().split()))
pa = list(map(int,input().strip().split()))
x = cr[k-1]+pa[0]
p = 0
if k==1:
print(1)
else:
for i in range(k-1):
if cr[i]+pa[-1]<=x:
p +=1
del pa[-1]
print(k-p)
``` | vfc_33817 | {
"difficulty": "9",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 3\n50 30 20 10\n15 10 7 3\n",
"output": "2",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 4\n29 25 13 10\n20 9 3 0\n",
"output": "1",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 2\n29 28 27 9\n1 1 1 0\n",
"output": "1",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 4\n29 25 13 9\n20 9 8 0\n",
"output": "2",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 1\n29 25 13 9\n3 2 1 0\n",
"output": "1",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 4\n29 25 13 0\n20 9 8 0\n",
"output": "3",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1070_B. Berkomnadzor | Solve the following coding problem using the programming language python:
Berkomnadzor β Federal Service for Supervision of Communications, Information Technology and Mass Media β is a Berland federal executive body that protects ordinary residents of Berland from the threats of modern internet.
Berkomnadzor maintains a list of prohibited IPv4 subnets (blacklist) and a list of allowed IPv4 subnets (whitelist). All Internet Service Providers (ISPs) in Berland must configure the network equipment to block access to all IPv4 addresses matching the blacklist. Also ISPs must provide access (that is, do not block) to all IPv4 addresses matching the whitelist. If an IPv4 address does not match either of those lists, it's up to the ISP to decide whether to block it or not. An IPv4 address matches the blacklist (whitelist) if and only if it matches some subnet from the blacklist (whitelist). An IPv4 address can belong to a whitelist and to a blacklist at the same time, this situation leads to a contradiction (see no solution case in the output description).
An IPv4 address is a 32-bit unsigned integer written in the form a.b.c.d, where each of the values a,b,c,d is called an octet and is an integer from 0 to 255 written in decimal notation. For example, IPv4 address 192.168.0.1 can be converted to a 32-bit number using the following expression 192 β
2^{24} + 168 β
2^{16} + 0 β
2^8 + 1 β
2^0. First octet a encodes the most significant (leftmost) 8 bits, the octets b and c β the following blocks of 8 bits (in this order), and the octet d encodes the least significant (rightmost) 8 bits.
The IPv4 network in Berland is slightly different from the rest of the world. There are no reserved or internal addresses in Berland and use all 2^{32} possible values.
An IPv4 subnet is represented either as a.b.c.d or as a.b.c.d/x (where 0 β€ x β€ 32). A subnet a.b.c.d contains a single address a.b.c.d. A subnet a.b.c.d/x contains all IPv4 addresses with x leftmost (most significant) bits equal to x leftmost bits of the address a.b.c.d. It is required that 32 - x rightmost (least significant) bits of subnet a.b.c.d/x are zeroes.
Naturally it happens that all addresses matching subnet a.b.c.d/x form a continuous range. The range starts with address a.b.c.d (its rightmost 32 - x bits are zeroes). The range ends with address which x leftmost bits equal to x leftmost bits of address a.b.c.d, and its 32 - x rightmost bits are all ones. Subnet contains exactly 2^{32-x} addresses. Subnet a.b.c.d/32 contains exactly one address and can also be represented by just a.b.c.d.
For example subnet 192.168.0.0/24 contains range of 256 addresses. 192.168.0.0 is the first address of the range, and 192.168.0.255 is the last one.
Berkomnadzor's engineers have devised a plan to improve performance of Berland's global network. Instead of maintaining both whitelist and blacklist they want to build only a single optimised blacklist containing minimal number of subnets. The idea is to block all IPv4 addresses matching the optimised blacklist and allow all the rest addresses. Of course, IPv4 addresses from the old blacklist must remain blocked and all IPv4 addresses from the old whitelist must still be allowed. Those IPv4 addresses which matched neither the old blacklist nor the old whitelist may be either blocked or allowed regardless of their accessibility before.
Please write a program which takes blacklist and whitelist as input and produces optimised blacklist. The optimised blacklist must contain the minimal possible number of subnets and satisfy all IPv4 addresses accessibility requirements mentioned above.
IPv4 subnets in the source lists may intersect arbitrarily. Please output a single number -1 if some IPv4 address matches both source whitelist and blacklist.
Input
The first line of the input contains single integer n (1 β€ n β€ 2β
10^5) β total number of IPv4 subnets in the input.
The following n lines contain IPv4 subnets. Each line starts with either '-' or '+' sign, which indicates if the subnet belongs to the blacklist or to the whitelist correspondingly. It is followed, without any spaces, by the IPv4 subnet in a.b.c.d or a.b.c.d/x format (0 β€ x β€ 32). The blacklist always contains at least one subnet.
All of the IPv4 subnets given in the input are valid. Integer numbers do not start with extra leading zeroes. The provided IPv4 subnets can intersect arbitrarily.
Output
Output -1, if there is an IPv4 address that matches both the whitelist and the blacklist. Otherwise output t β the length of the optimised blacklist, followed by t subnets, with each subnet on a new line. Subnets may be printed in arbitrary order. All addresses matching the source blacklist must match the optimised blacklist. All addresses matching the source whitelist must not match the optimised blacklist. You can print a subnet a.b.c.d/32 in any of two ways: as a.b.c.d/32 or as a.b.c.d.
If there is more than one solution, output any.
Examples
Input
1
-149.154.167.99
Output
1
0.0.0.0/0
Input
4
-149.154.167.99
+149.154.167.100/30
+149.154.167.128/25
-149.154.167.120/29
Output
2
149.154.167.99
149.154.167.120/29
Input
5
-127.0.0.4/31
+127.0.0.8
+127.0.0.0/30
-195.82.146.208/29
-127.0.0.6/31
Output
2
195.0.0.0/8
127.0.0.4/30
Input
2
+127.0.0.1/32
-127.0.0.1
Output
-1
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
#!/usr/bin/env python3
# Copied solution
import collections
import sys
import traceback
class Input(object):
def __init__(self):
self.fh = sys.stdin
def next_line(self):
while True:
line = sys.stdin.readline()
if line == '\n':
continue
return line
def next_line_ints(self):
line = self.next_line()
return [int(x) for x in line.split()]
def next_line_strs(self):
line = self.next_line()
return line.split()
class Node(object):
def __init__(self, color, subtree_color):
self.left = self.right = None
self.color = color
self.subtree_color = subtree_color
def list_to_number(list):
"""Return (color, bits, number)."""
color = 1 if list[0] == '-' else 2
values = list[1:].split('/')
bits = 32
if len(values) == 2:
bits = int(values[1])
nums = values[0].split('.')
number = 0
for num in nums:
number = number * 256 + int(num)
return (color, bits, number)
def add_list_to_tree(tree, list):
color, bits, number = list_to_number(list)
shift = 31
for _ in range(bits):
tree.subtree_color |= color
value = (number >> shift) & 1
if value == 0:
if not tree.left:
tree.left = Node(0, 0)
tree = tree.left
else:
if not tree.right:
tree.right = Node(0, 0)
tree = tree.right
shift -= 1
tree.subtree_color |= color
tree.color |= color
def check_tree(tree):
if not tree:
return True
if tree.color == 3 or (tree.color and (tree.subtree_color & ~tree.color)):
return False
return check_tree(tree.left) and check_tree(tree.right)
def number_to_list(number, bits):
number <<= (32 - bits)
values = []
for _ in range(4):
#print('number = {}'.format(number))
values.append(str(number % 256))
number //= 256
values = values[::-1]
return '.'.join(values) + '/' + str(bits)
def get_optimized(tree, optimized, number, bits):
if not tree or (tree.subtree_color & 1) == 0:
return
if tree.subtree_color == 1:
list = number_to_list(number, bits)
#print('number_to_list({}, {}) = {}'.format(number, bits, list))
optimized.append(list)
return
get_optimized(tree.left, optimized, number * 2, bits + 1)
get_optimized(tree.right, optimized, number * 2 + 1, bits + 1)
def get_optimized_lists(lists):
tree = Node(0, 0)
for list in lists:
add_list_to_tree(tree, list)
if not check_tree(tree):
return None
optimized = []
get_optimized(tree, optimized, 0, 0)
return optimized
def main():
input = Input()
while True:
try:
nums = input.next_line_ints()
if not nums:
break
n, = nums
if n == -1:
break
lists = []
for _ in range(n):
lists.append(input.next_line_strs()[0])
except:
print('read input failed')
try:
optimized = get_optimized_lists(lists)
if optimized is None:
print("-1")
else:
print("{}".format(len(optimized)))
for l in optimized:
print("{}".format(l))
except:
traceback.print_exc(file=sys.stdout)
print('get_min_dist failed')
main()
``` | vfc_33821 | {
"difficulty": "8",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 3, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n-127.0.0.4/31\n+127.0.0.8\n+127.0.0.0/30\n-195.82.146.208/29\n-127.0.0.6/31\n",
"output": "2\n127.0.0.4/30\n128.0.0.0/1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n-149.154.167.99\n+149.154.167.100/30\n+149.154.167.128/25\n-149.154.167.120/29\n",
"output": "2\n149.154.167.96/30\n149.154.167.112/28\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n+127.0.0.1/32\n-127.0.0.1\n",
"output": "-1",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n-149.154.167.99\n",
"output": "1\n0.0.0.0/0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "11\n-0.0.0.15/32\n-0.0.0.12/31\n-0.0.0.7/32\n-0.0.0.11/32\n-0.0.0.9/32\n-0.0.0.3\n-0.0.0.0/31\n-0.0.0.1/32\n-0.0.0.2/32\n-0.0.0.5\n-0.0.0.8/32\n",
"output": "1\n0.0.0.0/0\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1091_F. New Year and the Mallard Expedition | Solve the following coding problem using the programming language python:
Bob is a duck. He wants to get to Alice's nest, so that those two can duck!
<image> Duck is the ultimate animal! (Image courtesy of See Bang)
The journey can be represented as a straight line, consisting of n segments. Bob is located to the left of the first segment, while Alice's nest is on the right of the last segment. Each segment has a length in meters, and also terrain type: grass, water or lava.
Bob has three movement types: swimming, walking and flying. He can switch between them or change his direction at any point in time (even when he is located at a non-integer coordinate), and doing so doesn't require any extra time. Bob can swim only on the water, walk only on the grass and fly over any terrain. Flying one meter takes 1 second, swimming one meter takes 3 seconds, and finally walking one meter takes 5 seconds.
Bob has a finite amount of energy, called stamina. Swimming and walking is relaxing for him, so he gains 1 stamina for every meter he walks or swims. On the other hand, flying is quite tiring, and he spends 1 stamina for every meter flown. Staying in place does not influence his stamina at all. Of course, his stamina can never become negative. Initially, his stamina is zero.
What is the shortest possible time in which he can reach Alice's nest?
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the number of segments of terrain.
The second line contains n integers l_1, l_2, ..., l_n (1 β€ l_i β€ 10^{12}). The l_i represents the length of the i-th terrain segment in meters.
The third line contains a string s consisting of n characters "G", "W", "L", representing Grass, Water and Lava, respectively.
It is guaranteed that the first segment is not Lava.
Output
Output a single integer t β the minimum time Bob needs to reach Alice.
Examples
Input
1
10
G
Output
30
Input
2
10 10
WL
Output
40
Input
2
1 2
WL
Output
8
Input
3
10 10 10
GLW
Output
80
Note
In the first sample, Bob first walks 5 meters in 25 seconds. Then he flies the remaining 5 meters in 5 seconds.
In the second sample, Bob first swims 10 meters in 30 seconds. Then he flies over the patch of lava for 10 seconds.
In the third sample, the water pond is much smaller. Bob first swims over the water pond, taking him 3 seconds. However, he cannot fly over the lava just yet, as he only has one stamina while he needs two. So he swims back for half a meter, and then half a meter forward, taking him 3 seconds in total. Now he has 2 stamina, so he can spend 2 seconds flying over the lava.
In the fourth sample, he walks for 50 seconds, flies for 10 seconds, swims for 15 seconds, and finally flies for 5 seconds.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
from heapq import heappush, heappop
n = int(input())
L = list(map(int, input().split()))
T = input()
# fly -> walk, time cost: +4s, stamina: +2
# walk in place, time cost: +5s, stamina: +1
#fly -> swim, time cost: +2s, stamina: +2
#swim in place, time cost: +3s, stamina:+1
ans = sum(L)
Q = []
for l, t in zip(L, T):
if t == 'G':
heappush(Q, (2, 2 * l))
heappush(Q, (5, float('inf')))
elif t == 'W':
heappush(Q, (1, 2 * l))
heappush(Q, (3, float('inf')))
need_stamina = l
while need_stamina > 0:
cost, quantity = heappop(Q)
if need_stamina > quantity:
ans += quantity * cost
need_stamina -= quantity
else:
ans += need_stamina * cost
heappush(Q, (cost, quantity - need_stamina))
need_stamina = 0
print(ans)
``` | vfc_33825 | {
"difficulty": "12",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n1 2\nWL\n",
"output": "8",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n10 10 10\nGLW\n",
"output": "80",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n10 10\nWL\n",
"output": "40",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n10\nG\n",
"output": "30",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1110_D. Jongmah | Solve the following coding problem using the programming language python:
You are playing a game of Jongmah. You don't need to know the rules to solve this problem. You have n tiles in your hand. Each tile has an integer between 1 and m written on it.
To win the game, you will need to form some number of triples. Each triple consists of three tiles, such that the numbers written on the tiles are either all the same or consecutive. For example, 7, 7, 7 is a valid triple, and so is 12, 13, 14, but 2,2,3 or 2,4,6 are not. You can only use the tiles in your hand to form triples. Each tile can be used in at most one triple.
To determine how close you are to the win, you want to know the maximum number of triples you can form from the tiles in your hand.
Input
The first line contains two integers integer n and m (1 β€ n, m β€ 10^6) β the number of tiles in your hand and the number of tiles types.
The second line contains integers a_1, a_2, β¦, a_n (1 β€ a_i β€ m), where a_i denotes the number written on the i-th tile.
Output
Print one integer: the maximum number of triples you can form.
Examples
Input
10 6
2 3 3 3 4 4 4 5 5 6
Output
3
Input
12 6
1 5 3 3 3 4 3 5 3 2 3 3
Output
3
Input
13 5
1 1 5 1 2 3 3 2 4 2 3 4 5
Output
4
Note
In the first example, we have tiles 2, 3, 3, 3, 4, 4, 4, 5, 5, 6. We can form three triples in the following way: 2, 3, 4; 3, 4, 5; 4, 5, 6. Since there are only 10 tiles, there is no way we could form 4 triples, so the answer is 3.
In the second example, we have tiles 1, 2, 3 (7 times), 4, 5 (2 times). We can form 3 triples as follows: 1, 2, 3; 3, 3, 3; 3, 4, 5. One can show that forming 4 triples is not possible.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
from collections import Counter
n, m = map(int, input().split())
B = list(map(int, input().split()))
cnt = Counter(B)
A = sorted(cnt.keys())
n = len(A)
dp = [[0] * 3 for _ in range(3)]
for i, a in enumerate(A):
dp2 = [[0] * 3 for _ in range(3)]
for x in range(1 if i >= 2 and a - 2 != A[i - 2] else 3):
for y in range(1 if i >= 1 and a - 1 != A[i - 1] else 3):
for z in range(3):
if x + y + z <= cnt[a]:
dp2[y][z] = max(dp2[y][z], dp[x][y] + z + (cnt[a] - x - y - z) // 3)
dp = dp2
print (dp[0][0])
``` | vfc_33829 | {
"difficulty": "10",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 3, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "10 6\n2 3 3 3 4 4 4 5 5 6\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "13 5\n1 1 5 1 2 3 3 2 4 2 3 4 5\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "12 6\n1 5 3 3 3 4 3 5 3 2 3 3\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "14 9\n5 5 6 8 8 4 3 2 2 7 3 9 5 4\n",
"output": "4\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1140_A. Detective Book | Solve the following coding problem using the programming language python:
Ivan recently bought a detective book. The book is so interesting that each page of this book introduces some sort of a mystery, which will be explained later. The i-th page contains some mystery that will be explained on page a_i (a_i β₯ i).
Ivan wants to read the whole book. Each day, he reads the first page he didn't read earlier, and continues to read the following pages one by one, until all the mysteries he read about are explained and clear to him (Ivan stops if there does not exist any page i such that Ivan already has read it, but hasn't read page a_i). After that, he closes the book and continues to read it on the following day from the next page.
How many days will it take to read the whole book?
Input
The first line contains single integer n (1 β€ n β€ 10^4) β the number of pages in the book.
The second line contains n integers a_1, a_2, ..., a_n (i β€ a_i β€ n), where a_i is the number of page which contains the explanation of the mystery on page i.
Output
Print one integer β the number of days it will take to read the whole book.
Example
Input
9
1 3 3 6 7 6 8 8 9
Output
4
Note
Explanation of the example test:
During the first day Ivan will read only the first page. During the second day Ivan will read pages number 2 and 3. During the third day β pages 4-8. During the fourth (and the last) day Ivan will read remaining page number 9.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import sys
#p = [[] for i in range(N)]
#for i in range(N):
# p[i] += map(int, sys.stdin.readline().split())
#Q = input()
#for i in range(Q):
# print(list(map(int, sys.stdin.readline().split())))
n = int(input())
a = [int(c) for c in sys.stdin.readline().split()]
aktmax, d = 0, 0
for i, c in enumerate(a, start=1):
aktmax = max(aktmax, c)
if aktmax <= i:
d += 1
print(d)
``` | vfc_33833 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "9\n1 3 3 6 7 6 8 8 9\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1158_E. Strange device | Solve the following coding problem using the programming language python:
It is an interactive problem.
Vasya enjoys solving quizzes. He found a strange device and wants to know how it works.
This device encrypted with the tree (connected undirected graph without cycles) with n vertices, numbered with integers from 1 to n. To solve this quiz you should guess this tree.
Fortunately, this device can make one operation, using which you should guess the cipher. You can give the device an array d_1, d_2, β¦, d_n of non-negative integers. On the device, there are n lamps, i-th of them is connected with i-th vertex of the tree. For all i the light will turn on the i-th lamp, if there exist such vertex of the tree with number j β i that dist(i, j) β€ d_j. Let's define dist(i, j) as the distance between vertices i and j in tree or number of edges on the simple path between vertices i and j.
Vasya wants to solve this quiz using β€ 80 operations with the device and guess the tree. Help him!
Interaction
In the beginning, your program should read one integer n β the number of vertices of the tree which encrypts the device (2 β€ n β€ 1000).
After that, you can make several operations in the following format. To do operation print a symbol"?" (without quotes) and n integers d_1, d_2, β¦, d_n, separated by spaces after it. Please note, that for all i you can only use the numbers, satisfying the inequality 0 β€ d_i < n. After that, you should read a string s with length n, consisting of symbols "0" and "1" (without quotes). For all i the symbol s_i is equal to "0", if the lamp on the device, connected with i-th vertex of the tree is switched off and "1" otherwise.
After several operations, you should print guessed tree. To do it print the only symbol "!" (without quotes). In the next n-1 lines print 2 integers a_i, b_i β indexes of the vertices connected by i-th edge of the tree. This numbers should satisfy the conditions 1 β€ a_i, b_i β€ n and a_i β b_i. This edges should form a tree, which is equal to the hidden tree. After that, your program should terminate.
It is guaranteed, that in each test the tree is fixed before and won't change depending on your program's operations.
Your program can make from 0 to 80 operations with the device and after that guess the tree equal with the hidden.
If your program will make more than 80 operations it can get any verdict, because it will continue reading from closed input. If your program will make operation or print the answer in the incorrect format, it can get any verdict too. Be careful.
Don't forget to flush the output after printing questions and answers.
To flush the output, you can use:
* fflush(stdout) in C++.
* System.out.flush() in Java.
* stdout.flush() in Python.
* flush(output) in Pascal.
* See the documentation for other languages.
Hacks:
The first line should contain one integer n β the number of vertices in the tree (2 β€ n β€ 1000). Next n-1 lines should contain 2 integers a_i, b_i β indexes of the vertices connected by i-th edge of the tree (1 β€ a_i, b_i β€ n, a_i β b_i). All edges should form a tree. Be careful, extra spaces or line breaks are not allowed.
Example
Input
5
00000
11011
11100
10010
Output
? 0 0 0 0 0
? 1 1 2 0 2
? 0 0 0 1 0
? 0 1 0 0 1
!
4 2
1 5
3 4
4 1
Note
It is a picture of the tree which encrypt the device from the first test:
<image>
It is a table of pairwise distances between vertices in this tree:
<image>
* If you make operation where d = [0, 0, 0, 0, 0], no lamp will switch on, because dist(i, j) > 0 for all i β j.
* If you make operation where d = [1, 1, 2, 0, 2], all lamps except the lamp connected with the 3-rd vertex will switch on. For example, lamp connected with the 1-st vertex will switch on, because dist(1, 5) = 1 β€ 2 = d_5.
* If you make operation where d = [0, 0, 0, 1, 0], all lamps except lamps connected with the 4-th and 5-th vertices will switch on.
* If you make operation where d = [0, 1, 0, 0, 1], only lamps connected with the 1-st and 4-th vertices will switch on.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_33837 | {
"difficulty": "11",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n00000\n11011\n11100\n10010\n",
"output": "\n? 0 0 0 0 0\n? 1 1 2 0 2\n? 0 0 0 1 0\n? 0 1 0 0 1\n!\n4 2\n1 5\n3 4\n4 1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "20\n11 13\n20 16\n14 17\n1 11\n8 11\n4 16\n12 2\n2 20\n19 5\n10 7\n19 16\n8 7\n15 16\n17 10\n18 4\n3 7\n9 1\n1 12\n6 1\n",
"output": "? 16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 15 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 4 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 3 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 \n? 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 \n? 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 \n? 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n? 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n!\n0 2\n0 3\n0 4\n0 5\n0 6\n0 7\n0 8\n0 9\n0 10\n0 11\n0 12\n0 13\n0 14\n0 15\n0 16\n0 17\n0 18\n0 19\n0 20\n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 1180_D. Tolik and His Uncle | Solve the following coding problem using the programming language python:
This morning Tolik has understood that while he was sleeping he had invented an incredible problem which will be a perfect fit for Codeforces! But, as a "Discuss tasks" project hasn't been born yet (in English, well), he decides to test a problem and asks his uncle.
After a long time thinking, Tolik's uncle hasn't any ideas on how to solve it. But, he doesn't want to tell Tolik about his inability to solve it, so he hasn't found anything better than asking you how to solve this task.
In this task you are given a cell field n β
m, consisting of n rows and m columns, where point's coordinates (x, y) mean it is situated in the x-th row and y-th column, considering numeration from one (1 β€ x β€ n, 1 β€ y β€ m). Initially, you stand in the cell (1, 1). Every move you can jump from cell (x, y), which you stand in, by any non-zero vector (dx, dy), thus you will stand in the (x+dx, y+dy) cell. Obviously, you can't leave the field, but also there is one more important condition β you're not allowed to use one vector twice. Your task is to visit each cell of the field exactly once (the initial cell is considered as already visited).
Tolik's uncle is a very respectful person. Help him to solve this task!
Input
The first and only line contains two positive integers n, m (1 β€ n β
m β€ 10^{6}) β the number of rows and columns of the field respectively.
Output
Print "-1" (without quotes) if it is impossible to visit every cell exactly once.
Else print n β
m pairs of integers, i-th from them should contain two integers x_i, y_i (1 β€ x_i β€ n, 1 β€ y_i β€ m) β cells of the field in order of visiting, so that all of them are distinct and vectors of jumps between them are distinct too.
Notice that the first cell should have (1, 1) coordinates, according to the statement.
Examples
Input
2 3
Output
1 1
1 3
1 2
2 2
2 3
2 1
Input
1 1
Output
1 1
Note
The vectors from the first example in the order of making jumps are (0, 2), (0, -1), (1, 0), (0, 1), (0, -2).
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
# [0,0,0]
# [0,0,0]
# [1,0,0]
# [0,0,0]
# [0,0,0]
# [1,0,1]
# [0,0,0]
# [0,0,0]
# [1,1,1]
# [0,0,0]
# [0,0,0]
# [1,1,1]
# [0,0,1]
# [0,0,0]
# [0,0,0] 3,2
#
# 0,0 3,2
# 0,1 3,1
# 0,2 3,0
# 1,0 2,2
# 1,1 2,1
# 1,2 2,0
n, m = map(int, input().split())
ans = []
if n % 2 == 0:
for i in range(int(n / 2)):
for j in range(m):
ans.append(f'{i+1} {j+1}')
ans.append(f'{n-i} {m-j}')
else:
for i in range(int(n / 2)):
for j in range(m):
ans.append(f'{i+1} {j+1}')
ans.append(f'{n-i} {m-j}')
mid = int(n/2)
for j in range(m//2):
ans.append(f'{mid+1} {j+1}')
ans.append(f'{mid+1} {m-j}')
if m % 2 != 0:
ans.append(f'{n//2+1} {m//2+1}')
print('\n'.join(ans))
"""
0 0 0
0 0 0
1 0 0
0 0 0
1 0 0
0 0 1
1 1 0
0 0 1
1 1 0
0 1 1
1 1 1
0 1 1
1 1 1
1 1 1
"""
``` | vfc_33841 | {
"difficulty": "10",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "1 1\n",
"output": "1 1\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1199_D. Welfare State | Solve the following coding problem using the programming language python:
There is a country with n citizens. The i-th of them initially has a_{i} money. The government strictly controls the wealth of its citizens. Whenever a citizen makes a purchase or earns some money, they must send a receipt to the social services mentioning the amount of money they currently have.
Sometimes the government makes payouts to the poor: all citizens who have strictly less money than x are paid accordingly so that after the payout they have exactly x money. In this case the citizens don't send a receipt.
You know the initial wealth of every citizen and the log of all events: receipts and payouts. Restore the amount of money each citizen has after all events.
Input
The first line contains a single integer n (1 β€ n β€ 2 β
10^{5}) β the numer of citizens.
The next line contains n integers a_1, a_2, ..., a_n (0 β€ a_{i} β€ 10^{9}) β the initial balances of citizens.
The next line contains a single integer q (1 β€ q β€ 2 β
10^{5}) β the number of events.
Each of the next q lines contains a single event. The events are given in chronological order.
Each event is described as either 1 p x (1 β€ p β€ n, 0 β€ x β€ 10^{9}), or 2 x (0 β€ x β€ 10^{9}). In the first case we have a receipt that the balance of the p-th person becomes equal to x. In the second case we have a payoff with parameter x.
Output
Print n integers β the balances of all citizens after all events.
Examples
Input
4
1 2 3 4
3
2 3
1 2 2
2 1
Output
3 2 3 4
Input
5
3 50 2 1 10
3
1 2 0
2 8
1 3 20
Output
8 8 20 8 10
Note
In the first example the balances change as follows: 1 2 3 4 β 3 3 3 4 β 3 2 3 4 β 3 2 3 4
In the second example the balances change as follows: 3 50 2 1 10 β 3 0 2 1 10 β 8 8 8 8 10 β 8 8 20 8 10
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import sys
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def main():
n = int(input())
A = list(map(int, input().split()))
q = int(input())
Q = []
for i in range(q):
temp = list(map(int, input().split()))
t = temp[0]
if t == 1:
p, x = temp[1], temp[2]
p -= 1
Q.append((t, p, x))
else:
x = temp[1]
Q.append((t, -1, x))
Q.reverse()
B = [-1]*n
y = -1
for t, p, x in Q:
if t == 1:
if B[p] == -1:
B[p] = max(y, x)
else:
y = max(y, x)
#print(*B)
for i, b in enumerate(B):
if b != -1:
continue
B[i] = max(A[i], y)
print(*B)
if __name__ == '__main__':
main()
``` | vfc_33845 | {
"difficulty": "10",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n3 50 2 1 10\n3\n1 2 0\n2 8\n1 3 20\n",
"output": "8 8 20 8 10\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n1 2 3 4\n3\n2 3\n1 2 2\n2 1\n",
"output": "3 2 3 4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n1 2 3 4\n2\n2 3\n2 2\n",
"output": "3 3 3 4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n1 2 3 4\n2\n2 1000\n2 1\n",
"output": "1000 1000 1000 1000\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1216_C. White Sheet | 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 β€ x_1 < x_2 β€ 10^{6}, 0 β€ y_1 < y_2 β€ 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 β€ x_3 < x_4 β€ 10^{6}, 0 β€ y_3 < y_4 β€ 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 β€ x_5 < x_6 β€ 10^{6}, 0 β€ y_5 < y_6 β€ 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 given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
a=list(map(int,input().split()))
x1,y1,x2,y2=a[0],a[1],a[2],a[3]
a=list(map(int,input().split()))
x3,y3,x4,y4=a[0],a[1],a[2],a[3]
a=list(map(int,input().split()))
x5,y5,x6,y6=a[0],a[1],a[2],a[3]
l1=l2=l3=l4=1
if (x1>=x5 and x2<=x6 and y1>=y5 and y1<=y6) or (x1>=x3 and x2<=x4 and y1>=y3 and y1<=y4) or (y1>=y5 and y1<=y6 and y1>=y3 and y1<=y4 and x1>=min(x3,x5) and x2<=max(x4,x6) and x4>=x5 and x3<=x6):
l1=0
if (y1>=y5 and y2<=y6 and x1>=x5 and x1<=x6) or (y1>=y3 and y2<=y4 and x1>=x3 and x1<=x4) or (x1>=x5 and x1<=x6 and x1>=x3 and x1<=x4 and y1>=min(y3,y5) and y2<=max(y4,y6) and y4>=y5 and y3<=y6):
l2=0
if (x1>=x5 and x2<=x6 and y2>=y5 and y2<=y6) or (x1>=x3 and x2<=x4 and y2>=y3 and y2<=y4) or (y2>=y5 and y2<=y6 and y2>=y3 and y2<=y4 and x1>=min(x3,x5) and x2<=max(x4,x6) and x4>=x5 and x3<=x6):
l3=0
if (y1>=y5 and y2<=y6 and x2>=x5 and x2<=x6) or (y1>=y3 and y2<=y4 and x2>=x3 and x2<=x4) or (x2>=x5 and x2<=x6 and x2>=x3 and x2<=x4 and y1>=min(y3,y5) and y2<=max(y4,y6) and y4>=y5 and y3<=y6):
l4=0
if l1 or l2 or l3 or l4: print('YES')
else: print('NO')
``` | vfc_33849 | {
"difficulty": "9",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"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": "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": "2 2 4 4\n1 1 3 5\n3 1 5 5\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "7 1 8 3\n0 0 4 2\n2 1 18 21\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 2 10 5\n8 1 11 7\n3 1 7 6\n",
"output": "YES\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1257_F. Make Them Similar | Solve the following coding problem using the programming language python:
Let's call two numbers similar if their binary representations contain the same number of digits equal to 1. For example:
* 2 and 4 are similar (binary representations are 10 and 100);
* 1337 and 4213 are similar (binary representations are 10100111001 and 1000001110101);
* 3 and 2 are not similar (binary representations are 11 and 10);
* 42 and 13 are similar (binary representations are 101010 and 1101).
You are given an array of n integers a_1, a_2, ..., a_n. You may choose a non-negative integer x, and then get another array of n integers b_1, b_2, ..., b_n, where b_i = a_i β x (β denotes bitwise XOR).
Is it possible to obtain an array b where all numbers are similar to each other?
Input
The first line contains one integer n (2 β€ n β€ 100).
The second line contains n integers a_1, a_2, ..., a_n (0 β€ a_i β€ 2^{30} - 1).
Output
If it is impossible to choose x so that all elements in the resulting array are similar to each other, print one integer -1.
Otherwise, print any non-negative integer not exceeding 2^{30} - 1 that can be used as x so that all elements in the resulting array are similar.
Examples
Input
2
7 2
Output
1
Input
4
3 17 6 0
Output
5
Input
3
1 2 3
Output
-1
Input
3
43 12 12
Output
1073709057
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
def main():
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
dic1 = {}
dic2 = {}
A1 = [0] * N
for i, a in enumerate(A):
A1[i] = a>>15
for i in range(2**15):
tmp = [0] * N
for j, a in enumerate(A1):
a ^= i
tmp[j] = bin(a).count('1')
t0 = tmp[0]
for j in range(N):
tmp[j] -= t0
dic1[i] = tuple(tmp)
A2 = [0] * N
for i, a in enumerate(A):
A2[i] = a % (2**15)
for i in range(2 ** 15):
tmp = [0] * N
for j, a in enumerate(A2):
a ^= i
tmp[j] = -(bin(a).count('1'))
t0 = tmp[0]
for j in range(N):
tmp[j] -= t0
dic2[tuple(tmp)] = i
for i in range(2**15):
if dic1[i] in dic2:
# ans = i*(2**15) + dic2[dic1[i]]
# print([bin(a^ans).count('1') for a in A])
print(i*(2**15) + dic2[dic1[i]])
exit()
print(-1)
if __name__ == '__main__':
main()
``` | vfc_33857 | {
"difficulty": "12",
"memory_limit": null,
"memory_limit_bytes": 1024000000,
"problem_url": null,
"time_limit": "{'seconds': 4, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n3 17 6 0\n",
"output": "5\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n1 2 3\n",
"output": "-1",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n7 2\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n43 12 12\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n105953580 334230288\n",
"output": "32723\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1073709056 32767\n",
"output": "0\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1281_A. Suffix Three | Solve the following coding problem using the programming language python:
We just discovered a new data structure in our research group: a suffix three!
It's very useful for natural language processing. Given three languages and three suffixes, a suffix three can determine which language a sentence is written in.
It's super simple, 100% accurate, and doesn't involve advanced machine learning algorithms.
Let us tell you how it works.
* If a sentence ends with "po" the language is Filipino.
* If a sentence ends with "desu" or "masu" the language is Japanese.
* If a sentence ends with "mnida" the language is Korean.
Given this, we need you to implement a suffix three that can differentiate Filipino, Japanese, and Korean.
Oh, did I say three suffixes? I meant four.
Input
The first line of input contains a single integer t (1 β€ t β€ 30) denoting the number of test cases. The next lines contain descriptions of the test cases.
Each test case consists of a single line containing a single string denoting the sentence. Spaces are represented as underscores (the symbol "_") for ease of reading. The sentence has at least 1 and at most 1000 characters, and consists only of lowercase English letters and underscores. The sentence has no leading or trailing underscores and no two consecutive underscores. It is guaranteed that the sentence ends with one of the four suffixes mentioned above.
Output
For each test case, print a single line containing either "FILIPINO", "JAPANESE", or "KOREAN" (all in uppercase, without quotes), depending on the detected language.
Example
Input
8
kamusta_po
genki_desu
ohayou_gozaimasu
annyeong_hashimnida
hajime_no_ippo
bensamu_no_sentou_houhou_ga_okama_kenpo
ang_halaman_doon_ay_sarisari_singkamasu
si_roy_mustang_ay_namamasu
Output
FILIPINO
JAPANESE
JAPANESE
KOREAN
FILIPINO
FILIPINO
JAPANESE
JAPANESE
Note
The first sentence ends with "po", so it is written in Filipino.
The second and third sentences end with "desu" and "masu", so they are written in Japanese.
The fourth sentence ends with "mnida", so it is written in Korean.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
n = int(input())
for _ in range(n):
s = input().split("_")[-1:][0]
if s[-2:] == "po":
print("FILIPINO")
elif s[-4:] == "desu" or s[-4:] == "masu":
print("JAPANESE")
else:
print("KOREAN")
``` | vfc_33861 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "8\nkamusta_po\ngenki_desu\nohayou_gozaimasu\nannyeong_hashimnida\nhajime_no_ippo\nbensamu_no_sentou_houhou_ga_okama_kenpo\nang_halaman_doon_ay_sarisari_singkamasu\nsi_roy_mustang_ay_namamasu\n",
"output": "FILIPINO\nJAPANESE\nJAPANESE\nKOREAN\nFILIPINO\nFILIPINO\nJAPANESE\nJAPANESE\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "30\nopo\np_po\npopo\ndesu\npo\nudesu\npodesu\ndesupo\nsddesu\nmumasu\nmmnida\nmmasu\nmasu\ndesu_po\npomnida\nmasumasu\npppo\nmnida\nmasu_po\ndesu_masu\na_masu\npo_po\nmasupo\nmasu_masu\nmnidamasu\npomasu\nmnida_po\nmnida_desu\nnakupo\npo_masu\n",
"output": "FILIPINO\nFILIPINO\nFILIPINO\nJAPANESE\nFILIPINO\nJAPANESE\nJAPANESE\nFILIPINO\nJAPANESE\nJAPANESE\nKOREAN\nJAPANESE\nJAPANESE\nFILIPINO\nKOREAN\nJAPANESE\nFILIPINO\nKOREAN\nFILIPINO\nJAPANESE\nJAPANESE\nFILIPINO\nFILIPINO\nJAPANESE\nJAPANESE\nJAPANESE\nFILIPINO\nJAPANESE\nFILIPINO\nJAPANESE\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "30\npo\nppo\nop_po\nmnida\nmasu\ndesu\npopo\nmsmasu\npomasu\npo_po\nusedpo\nmasu_po\nopmasu\nopo\nua_masu\nop_masu\nmnidapo\ndmnida\nopdesu\nadinmpo\npodesu\nnakupo\noppo\nmmasu\np_po\nadinm_po\nused_po\nusedmasu\nm_umasu\no_ppo\n",
"output": "FILIPINO\nFILIPINO\nFILIPINO\nKOREAN\nJAPANESE\nJAPANESE\nFILIPINO\nJAPANESE\nJAPANESE\nFILIPINO\nFILIPINO\nFILIPINO\nJAPANESE\nFILIPINO\nJAPANESE\nJAPANESE\nFILIPINO\nKOREAN\nJAPANESE\nFILIPINO\nJAPANESE\nFILIPINO\nFILIPINO\nJAPANESE\nFILIPINO\nFILIPINO\nFILIPINO\nJAPANESE\nJAPANESE\nFILIPINO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "30\nmnidamnida\nopmnida\nadinm_masu\nusam_masu\nuseddesu\nadinmmasu\nmnida_po\ndnmnida\nmasumnida\nusam_po\nmnidadesu\nused_masu\nmnida_mnida\nadinm_mnida\nusammasu\nmasu_desu\nusammnida\ngenki_desu\nmm_mnida\nadinmmnida\nop_mnida\nadinm_desu\nused_desu\nusam_desu\nadinmdesu\nsaranghamnida\ndesu_desu\ntang_na_moo_po\nused_mnida\nusam_mnida\n",
"output": "KOREAN\nKOREAN\nJAPANESE\nJAPANESE\nJAPANESE\nJAPANESE\nFILIPINO\nKOREAN\nKOREAN\nFILIPINO\nJAPANESE\nJAPANESE\nKOREAN\nKOREAN\nJAPANESE\nJAPANESE\nKOREAN\nJAPANESE\nKOREAN\nKOREAN\nKOREAN\nJAPANESE\nJAPANESE\nJAPANESE\nJAPANESE\nKOREAN\nJAPANESE\nFILIPINO\nKOREAN\nKOREAN\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1301_A. Three Strings | Solve the following coding problem using the programming language python:
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 β€ i β€ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i β a_i or c_i β b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 β€ t β€ 100) β the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
t = int(input())
for T in range(t):
a = input()
b = input()
c = input()
n = len(a)
count = 0
for i in range(n):
if a[i] == c[i] or b[i] == c[i]:
count += 1
if count == n:
print("YES")
else:
print("NO")
``` | vfc_33865 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\naaa\nbbb\nccc\nabc\nbca\nbca\naabb\nbbaa\nbaba\nimi\nmii\niim\n",
"output": "NO\nYES\nYES\nNO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\nab\nab\nbb\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\nba\nab\nbb\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\naaa\nbbb\nccc\nabc\nbca\ncca\naabb\nbbaa\nbaba\nimi\nmii\niim\n",
"output": "NO\nNO\nYES\nNO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\naaa\nbbb\nccc\nabc\nbca\ncca\naabb\nbbaa\nbaba\niim\nmii\niim\n",
"output": "NO\nNO\nYES\nYES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\nba\nbb\ncb\n",
"output": "NO\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1325_A. EhAb AnD gCd | Solve the following coding problem using the programming language python:
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 β€ t β€ 100) β the number of testcases.
Each testcase consists of one line containing a single integer, x (2 β€ x β€ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 β€ a, b β€ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
# your code goes here
for _ in range(int(input())):
x=int(input())
print(1,end=" ")
print(x-1)
``` | vfc_33869 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n2\n14\n",
"output": "1 1\n1 13\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "100\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32\n33\n34\n35\n36\n37\n38\n39\n40\n41\n42\n43\n44\n45\n46\n47\n48\n49\n50\n51\n52\n53\n54\n55\n56\n57\n58\n59\n60\n61\n62\n63\n64\n65\n66\n67\n68\n69\n70\n71\n72\n73\n74\n75\n76\n77\n78\n79\n80\n81\n82\n83\n84\n85\n86\n87\n88\n89\n90\n91\n92\n93\n94\n95\n96\n97\n98\n99\n100\n101\n102\n103\n",
"output": "1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n1 87\n1 88\n1 89\n1 90\n1 91\n1 92\n1 93\n1 94\n1 95\n1 96\n1 97\n1 98\n1 99\n1 100\n1 101\n1 102\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "100\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32\n33\n34\n35\n36\n37\n38\n39\n40\n41\n42\n43\n44\n45\n46\n47\n48\n49\n50\n51\n52\n53\n54\n55\n56\n57\n58\n59\n60\n61\n62\n63\n64\n65\n66\n67\n68\n69\n70\n71\n72\n117\n74\n75\n76\n77\n78\n79\n80\n81\n82\n83\n84\n85\n86\n87\n88\n89\n90\n91\n92\n93\n94\n95\n96\n97\n98\n99\n100\n101\n102\n103\n",
"output": "1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 116\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n1 87\n1 88\n1 89\n1 90\n1 91\n1 92\n1 93\n1 94\n1 95\n1 96\n1 97\n1 98\n1 99\n1 100\n1 101\n1 102\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n2\n2\n",
"output": "1 1\n1 1\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1365_G. Secure Password | Solve the following coding problem using the programming language python:
This is an interactive problem.
Ayush devised yet another scheme to set the password of his lock. The lock has n slots where each slot can hold any non-negative integer. The password P is a sequence of n integers, i-th element of which goes into the i-th slot of the lock.
To set the password, Ayush comes up with an array A of n integers each in the range [0, 2^{63}-1]. He then sets the i-th element of P as the [bitwise OR](https://en.wikipedia.org/wiki/Bitwise_operation#OR) of all integers in the array except A_i.
You need to guess the password. To make a query, you can choose a non-empty subset of indices of the array and ask the bitwise OR all elements of the array with index in this subset. You can ask no more than 13 queries.
Input
The first line of input contains one integer n (2 β€ n β€ 1000) β the number of slots in the lock.
Interaction
To ask a query print a single line:
* In the beginning print "? c " (without quotes) where c (1 β€ c β€ n) denotes the size of the subset of indices being queried, followed by c distinct space-separated integers in the range [1, n].
For each query, you will receive an integer x β the bitwise OR of values in the array among all the indices queried. If the subset of indices queried is invalid or you exceeded the number of queries then you will get x = -1. In this case, you should terminate the program immediately.
When you have guessed the password, print a single line "! " (without quotes), followed by n space-separated integers β the password sequence.
Guessing the password does not count towards the number of queries asked.
The interactor is not adaptive. The array A does not change with queries.
After printing a query do not forget to output the end of the line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see the documentation for other languages.
Hacks
To hack the solution, use the following test format:
On the first line print a single integer n (2 β€ n β€ 1000) β the number of slots in the lock. The next line should contain n space-separated integers in the range [0, 2^{63} - 1] β the array A.
Example
Input
3
1
2
4
Output
? 1 1
? 1 2
? 1 3
! 6 5 3
Note
The array A in the example is \{{1, 2, 4\}}. The first element of the password is bitwise OR of A_2 and A_3, the second element is bitwise OR of A_1 and A_3 and the third element is bitwise OR of A_1 and A_2. Hence the password sequence is \{{6, 5, 3\}}.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_33877 | {
"difficulty": "13",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n\n1\n\n2\n\n4\n\n",
"output": "? 3 1 2 3\n? 3 1 2 3\n? 3 1 2 3\n? 3 1 2 3\n? 2 1 2\n? 2 1 3\n? 2 2 3\n! 0 0 0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n1 2 3\n",
"output": "? 3 1 2 3\n? 3 1 2 3\n? 3 1 2 3\n? 3 1 2 3\n? 2 1 2\n? 2 1 3\n? 2 2 3\n! 0 0 0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n1 2 4\n",
"output": "? 3 1 2 3\n? 3 1 2 3\n? 3 1 2 3\n? 3 1 2 3\n? 2 1 2\n? 2 1 3\n? 2 2 3\n! 0 0 0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n822981260158260519 28316250877914571 779547116602436424 578223540024979436 335408917861648766 74859962623690078 252509054433933439 9223372036854775807 760713016476190622 919845426262703496\n",
"output": "? 9 1 2 3 4 5 6 8 9 10 \n? 9 1 2 3 4 5 7 8 9 10 \n? 9 1 2 3 4 6 7 8 9 10 \n? 8 1 2 3 5 6 7 8 9 \n? 8 1 2 4 5 6 7 8 10 \n? 8 1 3 4 5 6 7 9 10 \n? 6 2 3 4 5 6 7 \n? 3 8 9 10 \n! 9223372036854775807 9223372036854775807 9223372036854775807 9223372036854775807 9223372036854775807 9223372036854775807 9223372036854775807 255007249005526399 551585022201493887 830729138418466815 \n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 1407_E. Egor in the Republic of Dagestan | Solve the following coding problem using the programming language python:
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads β in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 β€ n β€ 500000, 0 β€ m β€ 500000) β the number of cities and the number of roads.
The i-th of next m lines contains three integers β u_i, v_i and t_i (1 β€ u_i, v_i β€ n, t_i β \{0, 1\}) β numbers of cities connected by road and its type, respectively (0 β night road, 1 β morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule β a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 β 3. Otherwise, it's 1 β 2 β 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import sys
input = sys.stdin.readline
from collections import deque
n, m = map(int, input().split())
back = [[] for i in range(n)]
for _ in range(m):
u, v, w = map(int, input().split())
u -= 1
v -= 1
back[v].append((u,w))
out = [2] * n
outl = [-1] * n
outl[-1] = 0
q = deque([n - 1])
while q:
v = q.popleft()
for u, w in back[v]:
if out[u] != w:
out[u] = 1 - w
else:
if outl[u] == -1:
outl[u] = outl[v] + 1
q.append(u)
out = [v if v != 2 else 1 for v in out]
print(outl[0])
print(''.join(map(str,out)))
``` | vfc_33885 | {
"difficulty": "11",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 4\n1 2 0\n1 3 1\n2 3 0\n2 3 1\n",
"output": "2\n010\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 10\n1 2 0\n1 3 1\n1 4 0\n2 3 0\n2 3 1\n2 5 0\n3 4 0\n3 4 1\n4 2 1\n4 5 0\n",
"output": "-1\n01010",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 8\n1 1 0\n1 3 0\n1 3 1\n3 2 0\n2 1 0\n3 4 1\n2 4 0\n2 4 1\n",
"output": "3\n1100",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1428_C. ABBB | Solve the following coding problem using the programming language python:
Zookeeper is playing a game. In this game, Zookeeper must use bombs to bomb a string that consists of letters 'A' and 'B'. He can use bombs to bomb a substring which is either "AB" or "BB". When he bombs such a substring, the substring gets deleted from the string and the remaining parts of the string get concatenated.
For example, Zookeeper can use two such operations: AABABBA β AABBA β AAA.
Zookeeper wonders what the shortest string he can make is. Can you help him find the length of the shortest string?
Input
Each test contains multiple test cases. The first line contains a single integer t (1 β€ t β€ 20000) β the number of test cases. The description of the test cases follows.
Each of the next t lines contains a single test case each, consisting of a non-empty string s: the string that Zookeeper needs to bomb. It is guaranteed that all symbols of s are either 'A' or 'B'.
It is guaranteed that the sum of |s| (length of s) among all test cases does not exceed 2 β
10^5.
Output
For each test case, print a single integer: the length of the shortest string that Zookeeper can make.
Example
Input
3
AAA
BABA
AABBBABBBB
Output
3
2
0
Note
For the first test case, you can't make any moves, so the answer is 3.
For the second test case, one optimal sequence of moves is BABA β BA. So, the answer is 2.
For the third test case, one optimal sequence of moves is AABBBABBBB β AABBBABB β AABBBB β ABBB β AB β (empty string). So, the answer is 0.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
# from debug import *
import sys;input = sys.stdin.readline
for _ in range(int(input())):
s = input().strip()
stack = []
for i in s:
if stack and i == 'B': stack.pop()
else: stack.append(i)
print(len(stack))
``` | vfc_33889 | {
"difficulty": "9",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\nAAA\nBABA\nAABBBABBBB\n",
"output": "3\n2\n0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\nAAA\nAABA\nAABBBABBBB\n",
"output": "3\n2\n0\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1500_A. Going Home | Solve the following coding problem using the programming language python:
It was the third month of remote learning, Nastya got sick of staying at dormitory, so she decided to return to her hometown. In order to make her trip more entertaining, one of Nastya's friend presented her an integer array a.
Several hours after starting her journey home Nastya remembered about the present. To entertain herself she decided to check, are there four different indices x, y, z, w such that a_x + a_y = a_z + a_w.
Her train has already arrived the destination, but she still hasn't found the answer. Can you help her unravel the mystery?
Input
The first line contains the single integer n (4 β€ n β€ 200 000) β the size of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 2.5 β
10^6).
Output
Print "YES" if there are such four indices, and "NO" otherwise.
If such indices exist, print these indices x, y, z and w (1 β€ x, y, z, w β€ n).
If there are multiple answers, print any of them.
Examples
Input
6
2 1 5 2 7 4
Output
YES
2 3 1 6
Input
5
1 3 1 9 20
Output
NO
Note
In the first example a_2 + a_3 = 1 + 5 = 2 + 4 = a_1 + a_6. Note that there are other answer, for example, 2 3 4 6.
In the second example, we can't choose four indices. The answer 1 2 2 3 is wrong, because indices should be different, despite that a_1 + a_2 = 1 + 3 = 3 + 1 = a_2 + a_3
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
def show(x, y, z, w):
print("YES")
print(x+1, y+1, z+1, w+1)
exit(0)
n=int(input())
ara=list(int(x) for x in input().split())
n=min(n, 2000)
found={}
for i in range(0, n):
for j in range(i+1, n):
cur_sm=ara[i]+ara[j]
if cur_sm in found.keys() and found[cur_sm][0]!=i and found[cur_sm][1]!=j and found[cur_sm][0]!=j and found[cur_sm][1]!=i:
show(found[cur_sm][0], found[cur_sm][1], i, j);
found[cur_sm]=(i, j)
print("NO")
``` | vfc_33901 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n1 3 1 9 20\n",
"output": "\nNO",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\n2 1 5 2 7 4\n",
"output": "\nYES\n2 3 1 6 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n1 2 4 8 11\n",
"output": "YES\n3 4 1 5 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\n1 2 5 8 10 12\n",
"output": "YES\n3 4 1 6 ",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1525_C. Robot Collisions | Solve the following coding problem using the programming language python:
There are n robots driving along an OX axis. There are also two walls: one is at coordinate 0 and one is at coordinate m.
The i-th robot starts at an integer coordinate x_i~(0 < x_i < m) and moves either left (towards the 0) or right with the speed of 1 unit per second. No two robots start at the same coordinate.
Whenever a robot reaches a wall, it turns around instantly and continues his ride in the opposite direction with the same speed.
Whenever several robots meet at the same integer coordinate, they collide and explode into dust. Once a robot has exploded, it doesn't collide with any other robot. Note that if several robots meet at a non-integer coordinate, nothing happens.
For each robot find out if it ever explodes and print the time of explosion if it happens and -1 otherwise.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of testcases.
Then the descriptions of t testcases follow.
The first line of each testcase contains two integers n and m (1 β€ n β€ 3 β
10^5; 2 β€ m β€ 10^8) β the number of robots and the coordinate of the right wall.
The second line of each testcase contains n integers x_1, x_2, ..., x_n (0 < x_i < m) β the starting coordinates of the robots.
The third line of each testcase contains n space-separated characters 'L' or 'R' β the starting directions of the robots ('L' stands for left and 'R' stands for right).
All coordinates x_i in the testcase are distinct.
The sum of n over all testcases doesn't exceed 3 β
10^5.
Output
For each testcase print n integers β for the i-th robot output the time it explodes at if it does and -1 otherwise.
Example
Input
5
7 12
1 2 3 4 9 10 11
R R L L R R R
2 10
1 6
R R
2 10
1 3
L L
1 10
5
R
7 8
6 1 7 2 3 5 4
R L R L L L L
Output
1 1 1 1 2 -1 2
-1 -1
2 2
-1
-1 2 7 3 2 7 3
Note
Here is the picture for the seconds 0, 1, 2 and 3 of the first testcase:
<image>
Notice that robots 2 and 3 don't collide because they meet at the same point 2.5, which is not integer.
After second 3 robot 6 just drive infinitely because there's no robot to collide with.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
from collections import deque
def main():
t=int(input())
allans=[]
for _ in range(t):
n,m=readIntArr()
xes=readIntArr()
direction=input().split()
ans=[-1]*n
# moving to each other will collide first, followed by moving in same direction,
# then those moving in opposite directions will collide last.
def solve(xdi): # solve for odd and even indices separately
# xdi is [x,direction,index]
xdi.sort() # sort by x asc. x is unique
# print(xdi)
rightDeque=deque([]) # [x,index]
for x,d,i in xdi:
if d=='L': # try to match with largest R
if rightDeque:
xr,ir=rightDeque.pop()
time=(x-xr)//2
ans[i]=ans[ir]=time
else: # no R to match. reflect in x==0 and convert to right
rightDeque.appendleft([-x,i])
else:
rightDeque.append([x,i])
# finally, the remaining in the heap are all moving right.
while len(rightDeque)>=2:
xl,il=rightDeque.pop()
xl=m+(m-xl)
xr,ir=rightDeque.pop()
time=(xl-xr)//2
ans[il]=ans[ir]=time
evenxdi=[] # [x,direction,index]
oddxdi=[]
for i in range(n):
if xes[i]%2==0:
evenxdi.append([xes[i],direction[i],i])
else:
oddxdi.append([xes[i],direction[i],i])
solve(evenxdi)
solve(oddxdi)
allans.append(ans)
multiLineArrayOfArraysPrint(allans)
return
import sys
# input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
# def readFloatArr():
# return [float(x) for x in input().split()]
def makeArr(defaultValFactory,dimensionArr): # eg. makeArr(lambda:0,[n,m])
dv=defaultValFactory;da=dimensionArr
if len(da)==1:return [dv() for _ in range(da[0])]
else:return [makeArr(dv,da[1:]) for _ in range(da[0])]
def queryInteractive(i,j):
print('? {} {}'.format(i,j))
sys.stdout.flush()
return int(input())
def answerInteractive(ans):
print('! {}'.format(' '.join([str(x) for x in ans])))
sys.stdout.flush()
inf=float('inf')
MOD=10**9+7
# MOD=998244353
for _abc in range(1):
main()
``` | vfc_33905 | {
"difficulty": "9",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n7 12\n1 2 3 4 9 10 11\nR R L L R R R\n2 10\n1 6\nR R\n2 10\n1 3\nL L\n1 10\n5\nR\n7 8\n6 1 7 2 3 5 4\nR L R L L L L\n",
"output": "\n1 1 1 1 2 -1 2 \n-1 -1 \n2 2 \n-1 \n-1 2 7 3 2 7 3 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n20 50\n4 6 8 9 10 13 14 16 18 20 23 25 30 32 33 38 42 43 45 46\nL L L L L L L L L L R R R L L R R L R R\n",
"output": "5 5 9 11 9 11 15 15 19 19 10 4 1 1 4 -1 6 10 -1 6 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n10 20\n2 3 7 9 10 13 14 16 17 18\nL L R L L R R R L L\n",
"output": "6 -1 1 1 6 2 -1 1 2 1 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n10 20\n2 3 7 9 10 13 14 16 1 18\nL L R L L R R R L L\n",
"output": "6 2 1 1 6 -1 -1 1 2 1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n10 20\n2 3 11 9 10 13 14 16 17 18\nL L R L L R R R L L\n",
"output": "6 6 -1 6 6 2 -1 1 2 1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n20 50\n4 6 8 9 10 13 14 16 18 20 23 28 30 32 33 38 42 43 45 46\nL L L L L L L L L L R R R L L R R L R R\n",
"output": "5 5 9 11 9 11 15 15 19 19 5 17 1 1 5 17 6 49 49 6\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 156_E. Mrs. Hudson's Pancakes | Solve the following coding problem using the programming language python:
Mrs. Hudson hasn't made her famous pancakes for quite a while and finally she decided to make them again. She has learned m new recipes recently and she can't wait to try them. Those recipes are based on n special spices. Mrs. Hudson has these spices in the kitchen lying in jars numbered with integers from 0 to n - 1 (each spice lies in an individual jar). Each jar also has the price of the corresponding spice inscribed β some integer ai.
We know three values for the i-th pancake recipe: di, si, ci. Here di and ci are integers, and si is the pattern of some integer written in the numeral system with radix di. The pattern contains digits, Latin letters (to denote digits larger than nine) and question marks. Number x in the di-base numeral system matches the pattern si, if we can replace question marks in the pattern with digits and letters so that we obtain number x (leading zeroes aren't taken into consideration when performing the comparison). More formally: each question mark should be replaced by exactly one digit or exactly one letter. If after we replace all question marks we get a number with leading zeroes, we can delete these zeroes. For example, number 40A9875 in the 11-base numeral system matches the pattern "??4??987?", and number 4A9875 does not.
To make the pancakes by the i-th recipe, Mrs. Hudson should take all jars with numbers whose representation in the di-base numeral system matches the pattern si. The control number of the recipe (zi) is defined as the sum of number ci and the product of prices of all taken jars. More formally: <image> (where j is all such numbers whose representation in the di-base numeral system matches the pattern si).
Mrs. Hudson isn't as interested in the control numbers as she is in their minimum prime divisors. Your task is: for each recipe i find the minimum prime divisor of number zi. If this divisor exceeds 100, then you do not have to find it, print -1.
Input
The first line contains the single integer n (1 β€ n β€ 104). The second line contains space-separated prices of the spices a0, a1, ..., an - 1, where ai is an integer (1 β€ ai β€ 1018).
The third line contains the single integer m (1 β€ m β€ 3Β·104) β the number of recipes Mrs. Hudson has learned.
Next m lines describe the recipes, one per line. First you are given an integer di, written in the decimal numeral system (2 β€ di β€ 16). Then after a space follows the si pattern β a string from 1 to 30 in length, inclusive, consisting of digits from "0" to "9", letters from "A" to "F" and signs "?". Letters from "A" to "F" should be considered as digits from 10 to 15 correspondingly. It is guaranteed that all digits of the pattern (including the digits that are represented by letters) are strictly less than di. Then after a space follows an integer ci, written in the decimal numeral system (1 β€ ci β€ 1018).
Please do not use the %lld specificator to read or write 64-bit integers in Π‘++, in is preferred to use cin, cout, strings or the %I64d specificator instead.
Output
For each recipe count by what minimum prime number the control number is divided and print this prime number on the single line. If this number turns out larger than 100, print -1.
Examples
Input
1
1
1
2 ? 1
Output
2
Input
4
2 3 5 7
4
2 ?0 11
2 ?1 13
2 0? 17
2 1? 19
Output
3
2
23
2
Input
1
1000000000000000000
1
16 ?????????????? 1
Output
-1
Note
In the first test any one-digit number in the binary system matches. The jar is only one and its price is equal to 1, the number c is also equal to 1, the control number equals 2. The minimal prime divisor of 2 is 2.
In the second test there are 4 jars with numbers from 0 to 3, and the prices are equal 2, 3, 5 and 7 correspondingly β the first four prime numbers. In all recipes numbers should be two-digit. In the first recipe the second digit always is 0, in the second recipe the second digit always is 1, in the third recipe the first digit must be 0, in the fourth recipe the first digit always is 1. Consequently, the control numbers ββare as follows: in the first recipe 2 Γ 5 + 11 = 21 (the minimum prime divisor is 3), in the second recipe 3 Γ 7 + 13 = 44 (the minimum prime divisor is 2), in the third recipe 2 Γ 3 + 17 = 23 (the minimum prime divisor is 23) and, finally, in the fourth recipe 5 Γ 7 + 19 = 54 (the minimum prime divisor is 2).
In the third test, the number should consist of fourteen digits and be recorded in a sixteen-base numeral system. Number 0 (the number of the single bottles) matches, the control number will be equal to 1018 + 1. The minimum prime divisor of this number is equal to 101 and you should print -1.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_33909 | {
"difficulty": "11",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 5, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "1\n1\n1\n2 ? 1\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1000000000000000000\n1\n16 ?????????????? 1\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n2 3 5 7\n4\n2 ?0 11\n2 ?1 13\n2 0? 17\n2 1? 19\n",
"output": "3\n2\n23\n2\n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 177_G2. Fibonacci Strings | Solve the following coding problem using the programming language python:
Fibonacci strings are defined as follows:
* f1 = Β«aΒ»
* f2 = Β«bΒ»
* fn = fn - 1 fn - 2, n > 2
Thus, the first five Fibonacci strings are: "a", "b", "ba", "bab", "babba".
You are given a Fibonacci string and m strings si. For each string si, find the number of times it occurs in the given Fibonacci string as a substring.
Input
The first line contains two space-separated integers k and m β the number of a Fibonacci string and the number of queries, correspondingly.
Next m lines contain strings si that correspond to the queries. It is guaranteed that strings si aren't empty and consist only of characters "a" and "b".
The input limitations for getting 30 points are:
* 1 β€ k β€ 3000
* 1 β€ m β€ 3000
* The total length of strings si doesn't exceed 3000
The input limitations for getting 100 points are:
* 1 β€ k β€ 1018
* 1 β€ m β€ 104
* The total length of strings si doesn't exceed 105
Please do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
For each string si print the number of times it occurs in the given Fibonacci string as a substring. Since the numbers can be large enough, print them modulo 1000000007 (109 + 7). Print the answers for the strings in the order in which they are given in the input.
Examples
Input
6 5
a
b
ab
ba
aba
Output
3
5
3
3
1
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
F = ['', 'a', 'b', 'ba', 'bab', 'babba', 'babbabab', 'babbababbabba', 'babbababbabbababbabab', 'babbababbabbababbababbabbababbabba', 'babbababbabbababbababbabbababbabbababbababbabbababbabab', 'babbababbabbababbababbabbababbabbababbababbabbababbababbabbababbabbababbababbabbababbabba', 'babbababbabbababbababbabbababbabbababbababbabbababbababbabbababbabbababbababbabbababbabbababbababbabbababbababbabbababbabbababbababbabbababbabab', 'babbababbabbababbababbabbababbabbababbababbabbababbababbabbababbabbababbababbabbababbabbababbababbabbababbababbabbababbabbababbababbabbababbababbabbababbabbababbababbabbababbabbababbababbabbababbababbabbababbabbababbababbabbababbabba', 'babbababbabbababbababbabbababbabbababbababbabbababbababbabbababbabbababbababbabbababbabbababbababbabbababbababbabbababbabbababbababbabbababbababbabbababbabbababbababbabbababbabbababbababbabbababbababbabbababbabbababbababbabbababbabbababbababbabbababbababbabbababbabbababbababbabbababbababbabbababbabbababbababbabbababbabbababbababbabbababbababbabbababbabbababbababbabbababbabab']
while len(F[-3]) < 100000: F.append(F[-1] + F[-2])
d = 1000000007
def sqr(t):
return [[sum(t[i][k] * t[k][j] for k in range(4)) % d for j in range(4)] for i in range(4)]
def mul(a, b):
return [[sum(a[i][k] * b[k][j] for k in range(4)) % d for j in range(4)] for i in range(4)]
def fib(k):
s, p = format(k, 'b')[:: -1], [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
t = [[[0, 1, 0, 0], [1, 1, 1, 0], [0, 0, 0, 1], [0, 0, 1, 0]]] + [0] * (len(s) - 1)
for i in range(1, len(s)):
t[i] = sqr(t[i - 1])
for i, k in enumerate(s):
if k == '1': p = mul(p, t[i])
return p
def cnt(t, p):
s, i = 0, p.find(t) + 1
while i > 0:
i = p.find(t, i) + 1
s += 1
return s
def f(t, p, k):
l = len(t) - 1
if l: x, y = cnt(t, F[k - 1][- l: ] + F[k][:l ]), cnt(t, F[k][- l: ] + F[k + 1][:l ])
else: x, y = 0, 0
a, b = cnt(t, F[k - 1]), cnt(t, F[k])
return (p[0] * a + p[1] * b + p[2] * y + p[3] * x) % d
k, m = map(int, input().split())
if k > 15:
x, y, z = len(F[7]), len(F[17]), len(F) - 4
a, b, c = fib(k - 7)[0], fib(k - 17)[0], fib(k - z)[0]
for i in range(m):
t = input()
if len(t) < x: print(f(t, a, 8))
elif len(t) < y: print(f(t, b, 18))
else: print(f(t, c, z + 1))
else:
p = F[k]
for i in range(m):
print(cnt(input(), p))
``` | vfc_33913 | {
"difficulty": "13",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6 5\na\nb\nab\nba\naba\n",
"output": "3\n5\n3\n3\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 14\na\nb\naa\nab\nba\nbb\naaa\naab\naba\nabb\nbaa\nbab\nbba\nbbb\n",
"output": "0\n1\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 10\nb\na\nb\na\nb\na\nb\na\nb\na\n",
"output": "0\n1\n0\n1\n0\n1\n0\n1\n0\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10 10\nbbb\nabb\nbab\naab\nbba\naba\nbaa\naaa\nbbb\nabb\n",
"output": "0\n12\n21\n0\n12\n8\n0\n0\n0\n12\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 19_A. World Football Cup | Solve the following coding problem using the programming language python:
Everyone knows that 2010 FIFA World Cup is being held in South Africa now. By the decision of BFA (Berland's Football Association) next World Cup will be held in Berland. BFA took the decision to change some World Cup regulations:
* the final tournament features n teams (n is always even)
* the first n / 2 teams (according to the standings) come through to the knockout stage
* the standings are made on the following principle: for a victory a team gets 3 points, for a draw β 1 point, for a defeat β 0 points. In the first place, teams are ordered in the standings in decreasing order of their points; in the second place β in decreasing order of the difference between scored and missed goals; in the third place β in the decreasing order of scored goals
* it's written in Berland's Constitution that the previous regulation helps to order the teams without ambiguity.
You are asked to write a program that, by the given list of the competing teams and the results of all the matches, will find the list of teams that managed to get through to the knockout stage.
Input
The first input line contains the only integer n (1 β€ n β€ 50) β amount of the teams, taking part in the final tournament of World Cup. The following n lines contain the names of these teams, a name is a string of lower-case and upper-case Latin letters, its length doesn't exceed 30 characters. The following nΒ·(n - 1) / 2 lines describe the held matches in the format name1-name2 num1:num2, where name1, name2 β names of the teams; num1, num2 (0 β€ num1, num2 β€ 100) β amount of the goals, scored by the corresponding teams. Accuracy of the descriptions is guaranteed: there are no two team names coinciding accurate to the letters' case; there is no match, where a team plays with itself; each match is met in the descriptions only once.
Output
Output n / 2 lines β names of the teams, which managed to get through to the knockout stage in lexicographical order. Output each name in a separate line. No odd characters (including spaces) are allowed. It's guaranteed that the described regulations help to order the teams without ambiguity.
Examples
Input
4
A
B
C
D
A-B 1:1
A-C 2:2
A-D 1:0
B-C 1:0
B-D 0:3
C-D 0:3
Output
A
D
Input
2
a
A
a-A 2:1
Output
a
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import sys
# from itertools import product
import logging
logging.root.setLevel(level=logging.INFO)
team_size = int(sys.stdin.readline())
teams = {}
for _ in range(team_size):
name = sys.stdin.readline().strip()
teams[name] = {
"point":0,
"delta":0,
"score":0
}
contest_size = team_size*(team_size-1)//2
logging.info(teams)
for _ in range(contest_size):
team, score = sys.stdin.readline().strip().split()
team1,team2 = team.split("-")
score1, score2 = map(int,score.split(":"))
logging.info(team1)
logging.info(score1)
logging.info(team2)
logging.info(score2)
teams[team1]["score"] += score1
teams[team2]["score"] += score2
teams[team1]["delta"] += score1 - score2
teams[team2]["delta"] += score2 - score1
teams[team1]["point"] += bool(score1 >= score2) + 2*bool(score1 > score2)
teams[team2]["point"] += bool(score2 >= score1) + 2*bool(score2 > score1)
logging.info(teams)
rank = sorted(teams.keys(),key = lambda x:(teams[x]['point'],teams[x]['delta'],teams[x]['score']),reverse=True)
logging.info(rank)
knockout = rank[:team_size//2]
knockout.sort()
print("\n".join(knockout))
``` | vfc_33917 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 64000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\nA\nB\nC\nD\nA-B 1:1\nA-C 2:2\nA-D 1:0\nB-C 1:0\nB-D 0:3\nC-D 0:3\n",
"output": "A\nD\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 223_B. Two Strings | Solve the following coding problem using the programming language python:
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is a string x = sk1sk2... sk|x| (1 β€ k1 < k2 < ... < k|x| β€ |s|).
You've got two strings β s and t. Let's consider all subsequences of string s, coinciding with string t. Is it true that each character of string s occurs in at least one of these subsequences? In other words, is it true that for all i (1 β€ i β€ |s|), there is such subsequence x = sk1sk2... sk|x| of string s, that x = t and for some j (1 β€ j β€ |x|) kj = i.
Input
The first line contains string s, the second line contains string t. Each line consists only of lowercase English letters. The given strings are non-empty, the length of each string does not exceed 2Β·105.
Output
Print "Yes" (without the quotes), if each character of the string s occurs in at least one of the described subsequences, or "No" (without the quotes) otherwise.
Examples
Input
abab
ab
Output
Yes
Input
abacaba
aba
Output
No
Input
abc
ba
Output
No
Note
In the first sample string t can occur in the string s as a subsequence in three ways: abab, abab and abab. In these occurrences each character of string s occurs at least once.
In the second sample the 4-th character of the string s doesn't occur in any occurrence of string t.
In the third sample there is no occurrence of string t in string s.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import bisect
import string
s = input()
t = input()
max_match = [0 for i in range(len(s))]
min_match = [0 for i in range(len(s))]
char_idx = [0 for i in range(30)]
char_occur = [ [] for i in range(30) ]
for (i, ch) in enumerate(t):
idx = ord(ch) - ord('a')
char_occur[idx].append(i)
for ch in string.ascii_lowercase:
idx = ord(ch) - ord('a')
char_occur[idx].append(len(t)+1)
matched = -1
for (i, ch) in enumerate(s):
if matched==len(t)-1:
max_match[i] = matched
else:
if ch == t[matched+1]:
matched += 1
max_match[i] = matched
matched = len(t)
for (i, ch) in enumerate(s[::-1]):
i = len(s) - i - 1
if matched==0:
min_match[i] = matched
else:
if ch == t[matched-1]:
matched -= 1
min_match[i] = matched
for (i, ch) in enumerate(s):
low = min_match[i]
high = max_match[i]
ch = ord(ch) - ord('a')
idx = char_idx[ch]
while idx<len(char_occur[ch]) and char_occur[ch][idx]<low:
idx += 1
char_idx[ch] = idx
if idx == len(char_occur[ch]):
print("No")
exit()
if char_occur[ch][idx] > high:
print("No")
exit()
print("Yes")
``` | vfc_33921 | {
"difficulty": "8",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "abc\nba\n",
"output": "No\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "abacaba\naba\n",
"output": "No\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "abab\nab\n",
"output": "Yes\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "abcdadbcd\nabcd\n",
"output": "Yes\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "cctckkhatkgrhktihcgififfgfctctkrgiakrifazzggfzczfkkahhafhcfgacccfakkarcatkfiktczkficahgiriakccfiztkhkgrfkrimgamighhtamrhxftaadwxgfggytwjccgkdpyyatctfdygxggkyycpjyfxyfdwtgytcacawjddjdctyfgddkfkypyxftxxtaddcxxpgfgxgdfggfdggdcddtgpxpctpddcdcpc\nctkhagrifaztmnxhmqztzibnmzzkojiztvrkfeoqegvwtbxlvvjhebshqaicsovtkcdovytimjggglyxlvglgunbohnkxargymbqvzgsnvjzgxivdgnaesgxcetveehlbmeskptivsuhuqupbieumycwczxyqjtwfofehfkpqmjngygwxkaviuyouiippgvlxjgtkxmhcwtzacbllsybgiujyryngapfwjkkyapfgxtcdpc\n",
"output": "No\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "bacbbcbcacaacbabacbcbacaaaabbabaaccccacbcbbbabcacbacacabaabacacbaaacacbbccbcccbabccaacccccbbcabacbaacabaccccccacbbaccbabaaabaaccabcaaabcccccbbabccccccabacbaaababcbbbccbbabcabbbbaaabbccccbacbaacbcacbbaaccbaabcaaacbccccbcbababccbcccabbbabbba\nbacbbcbcacaacbabacbcbacaaaabbabaaccccacbcbbbabcacbacacabaabacacbaaacacbbccbcccbabccaacccccbbcabacbaacabaccccccacbbaccbabaaabaaccabcaaabcccccbbabccccccabacbaaababcbbbccbbabcabbbbaaabbccccbacbaacbcacbbaaccbaabcaaacbccccbcbababccbcccabbbabbba\n",
"output": "Yes\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 272_A. Dima and Friends | Solve the following coding problem using the programming language python:
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 β€ n β€ 100) β the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
def solve(n,d):
other = 0
for i in d:
other += i
ways = 0
for i in range(1,6):
if (other + i) % (n + 1) != 1:
ways += 1
print(ways)
def main():
n = int(input())
d = input()
d = [int(i) for i in d.split()]
solve(n,d)
main()
``` | vfc_33929 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "1\n2\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 295_C. Greg and Friends | Solve the following coding problem using the programming language python:
One day Greg and his friends were walking in the forest. Overall there were n people walking, including Greg. Soon he found himself in front of a river. The guys immediately decided to get across the river. Luckily, there was a boat by the river bank, just where the guys were standing. We know that the boat can hold people with the total weight of at most k kilograms.
Greg immediately took a piece of paper and listed there the weights of all people in his group (including himself). It turned out that each person weights either 50 or 100 kilograms. Now Greg wants to know what minimum number of times the boat needs to cross the river to transport the whole group to the other bank. The boat needs at least one person to navigate it from one bank to the other. As the boat crosses the river, it can have any non-zero number of passengers as long as their total weight doesn't exceed k.
Also Greg is wondering, how many ways there are to transport everybody to the other side in the minimum number of boat rides. Two ways are considered distinct if during some ride they have distinct sets of people on the boat.
Help Greg with this problem.
Input
The first line contains two integers n, k (1 β€ n β€ 50, 1 β€ k β€ 5000) β the number of people, including Greg, and the boat's weight limit. The next line contains n integers β the people's weights. A person's weight is either 50 kilos or 100 kilos.
You can consider Greg and his friends indexed in some way.
Output
In the first line print an integer β the minimum number of rides. If transporting everyone to the other bank is impossible, print an integer -1.
In the second line print the remainder after dividing the number of ways to transport the people in the minimum number of rides by number 1000000007 (109 + 7). If transporting everyone to the other bank is impossible, print integer 0.
Examples
Input
1 50
50
Output
1
1
Input
3 100
50 50 100
Output
5
2
Input
2 50
50 50
Output
-1
0
Note
In the first test Greg walks alone and consequently, he needs only one ride across the river.
In the second test you should follow the plan:
1. transport two 50 kg. people;
2. transport one 50 kg. person back;
3. transport one 100 kg. person;
4. transport one 50 kg. person back;
5. transport two 50 kg. people.
That totals to 5 rides. Depending on which person to choose at step 2, we can get two distinct ways.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
from collections import deque
n, k = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
c50 = sum([1 for i in a if i == 50])
c100 = sum([1 for i in a if i == 100])
c = [[0] * 51 for i in range(51)]
c[0][0] = 1
c[1][0] = 1
c[1][1] = 1
for x in range(2, 51):
for y in range(x + 1):
c[x][y] = c[x - 1][y - 1] + c[x - 1][y]
d = [[[[0, float('inf')] for l in range(2)] for i in range(c100 + 1)] for j in range(c50 + 1)]
# d[i][j][c] ΠΎΡΠ²Π΅Ρ, ΠΊΠΎΠ³Π΄Π° ΠΌΡ ΠΏΠ΅ΡΠ΅ΠΏΡΠ°Π²ΠΈΠ»ΠΈ i ΠΏΠΎ 50 ΠΊΠ³ ΠΈ j ΠΏΠΎ 100 ΠΊΠ³ ΠΈ Π»ΠΎΠ΄ΠΊΠ° Π½Π° Π±Π΅ΡΠ΅Π³Ρ c
d[0][0][0][0] = 1
d[0][0][0][1] = 0
q = deque()
q.append([0, 0, 0])
while len(q) > 0:
i, j, shore = q.popleft()
for fifty in range(c50 - i + 1 if shore == 0 else i + 1):
for hundreds in range(c100 - j + 1 if shore == 0 else j + 1):
if fifty * 50 + hundreds * 100 > k or fifty + hundreds == 0:
continue
i1 = i + fifty if shore == 0 else i - fifty
j1 = j + hundreds if shore == 0 else j - hundreds
if d[i1][j1][1 ^ shore][1] > d[i][j][shore][1] + 1:
d[i1][j1][1 ^ shore][1] = d[i][j][shore][1] + 1
d[i1][j1][1 ^ shore][0] = 0
q.append((i1, j1, 1 ^ shore))
if d[i1][j1][1 ^ shore][1] < d[i][j][shore][1] + 1:
continue
koeff = (c[c50 - i][fifty] if shore == 0 else c[i][fifty]) * (
c[c100 - j][hundreds] if shore == 0 else c[j][hundreds])
d[i1][j1][1 ^ shore][0] += d[i][j][shore][0] * koeff
d[i1][j1][1 ^ shore][0] %= 10 ** 9 + 7
if d[c50][c100][1][1] == float('inf'):
print(-1)
print(0)
else:
print(d[c50][c100][1][1])
print(d[c50][c100][1][0])
``` | vfc_33933 | {
"difficulty": "9",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 100\n50 50 100\n",
"output": "5\n 2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 50\n50\n",
"output": "1\n 1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 50\n50 50\n",
"output": "-1\n0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 188\n50 50 50 50 50\n",
"output": "3\n 30\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 319_A. Malek Dance Club | Solve the following coding problem using the programming language python:
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying Β«XORΒ» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as Β«^Β», in Pascal β Β«xorΒ».
Input
The first line of input contains a binary number x of lenght n, (1 β€ n β€ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
s = input()
res = pow(2, len(s)-1)*(int(s, 2))
print (res%1000000007)
``` | vfc_33937 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "1\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "01\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "11\n",
"output": "6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "0111001111110010000001111100110100111110001100100001111111110000010010111010010010010111000110001111\n",
"output": "777947548\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10110\n",
"output": "352\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 343_A. Rational Resistance | Solve the following coding problem using the programming language python:
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 β€ a, b β€ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number β the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
I = lambda : list(map(int, input().split(' ')))
a, b = I()
ans = 0
while a > 0 and b > 0 and a//b > 0 or b//a > 0:
ans += a//b
a, b = b, a%b
print(ans)
``` | vfc_33941 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 2\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 1\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "199 200\n",
"output": "200\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4052739537881 6557470319842\n",
"output": "62\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 923438\n",
"output": "923438\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 366_C. Dima and Salad | Solve the following coding problem using the programming language python:
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem β now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 β€ n β€ 100, 1 β€ k β€ 10). The second line of the input contains n integers a1, a2, ..., an (1 β€ ai β€ 100) β the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 β€ bi β€ 100) β the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer β the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
from bisect import bisect_right
n, k = map(int, input().split())
t = sorted((u - k * v, v) for u, v in zip(*(map(int, input().split()), map(int, input().split()))))
m = n - bisect_right(t, (0, 0))
l, p, t = 0, [0] * 100001, t[:: -1]
for d, v in t[: m]:
for j in range(l, 0, -1):
if p[j]: p[j + d] = max(p[j + d], p[j] + v)
p[d] = max(p[d], p[0] + v)
l += d
for d, v in t[m: ]:
for j in range(- d, l + 1):
if p[j]: p[j + d] = max(p[j + d], p[j] + v)
print(p[0] * k if p[0] else -1)
``` | vfc_33945 | {
"difficulty": "9",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5 3\n4 4 4 4 4\n2 2 2 2 2\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 2\n10 8 1\n2 7 1\n",
"output": "18\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 1\n1\n2\n",
"output": "-1\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 40_A. Find Color | Solve the following coding problem using the programming language python:
Not so long ago as a result of combat operations the main Berland place of interest β the magic clock β was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y β the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
# _
#####################################################################################################################
from math import sqrt, ceil
def colorOfDamagedArea(x, y):
location = sqrt(x*x+y*y)
area_sBorder = ceil(location)
if location == area_sBorder:
return 'black'
area_sAddress = x*y
area_sColorCode = area_sBorder%2
if area_sAddress > 0 and area_sColorCode or area_sAddress < 0 and not area_sColorCode:
return 'black'
return 'white'
print(colorOfDamagedArea(*map(int, input().split())))
``` | vfc_33953 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "-2 1\n",
"output": "white\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 3\n",
"output": "black\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 437_E. The Child and Polygon | Solve the following coding problem using the programming language python:
This time our child has a simple polygon. He has to find the number of ways to split the polygon into non-degenerate triangles, each way must satisfy the following requirements:
* each vertex of each triangle is one of the polygon vertex;
* each side of the polygon must be the side of exactly one triangle;
* the area of intersection of every two triangles equals to zero, and the sum of all areas of triangles equals to the area of the polygon;
* each triangle must be completely inside the polygon;
* each side of each triangle must contain exactly two vertices of the polygon.
The picture below depicts an example of a correct splitting.
<image>
Please, help the child. Calculate the described number of ways modulo 1000000007 (109 + 7) for him.
Input
The first line contains one integer n (3 β€ n β€ 200) β the number of vertices of the polygon. Then follow n lines, each line containing two integers. The i-th line contains xi, yi (|xi|, |yi| β€ 107) β the i-th vertex of the polygon in clockwise or counterclockwise order.
It's guaranteed that the polygon is simple.
Output
Output the number of ways modulo 1000000007 (109 + 7).
Examples
Input
4
0 0
0 1
1 1
1 0
Output
2
Input
4
0 0
1 0
0 1
-1 0
Output
1
Input
5
0 0
1 0
1 1
0 1
-2 -1
Output
3
Note
In the first sample, there are two possible splittings:
<image>
In the second sample, there are only one possible splitting:
<image>
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_33957 | {
"difficulty": "11",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n0 0\n1 0\n0 1\n-1 0\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n0 0\n1 0\n1 1\n0 1\n-2 -1\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n0 0\n0 1\n1 1\n1 0\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "40\n5 11\n19 17\n23 5\n34 10\n40 22\n34 25\n39 37\n13 40\n-7 39\n-38 39\n-3 16\n1 15\n-3 15\n-34 14\n-33 2\n-27 0\n-27 -3\n-18 -3\n-37 -11\n-37 -13\n-22 -5\n-20 -9\n-24 -29\n-5 0\n-10 -12\n-16 -28\n-15 -34\n-10 -26\n-11 -22\n31 -36\n-9 -12\n-5 -13\n38 -37\n15 -16\n6 0\n0 7\n18 -6\n30 -17\n40 -25\n30 -15\n",
"output": "950152765\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n0 0\n2 0\n4 0\n2 1\n2 3\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "20\n-232 -887\n-232 -885\n-232 -883\n-232 -880\n-232 -879\n-232 -878\n-232 -875\n-232 -874\n-232 -871\n-232 -869\n-232 -866\n-232 -864\n-232 -862\n-232 -859\n-232 -858\n-232 -856\n-232 -854\n-232 -852\n-232 -851\n10000000 -850\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 45_G. Prime Problem | Solve the following coding problem using the programming language python:
In Berland prime numbers are fashionable β the respectable citizens dwell only on the floors with numbers that are prime numbers. The numismatists value particularly high the coins with prime nominal values. All the prime days are announced holidays!
Yet even this is not enough to make the Berland people happy. On the main street of the capital stand n houses, numbered from 1 to n. The government decided to paint every house a color so that the sum of the numbers of the houses painted every color is a prime number.
However it turned out that not all the citizens approve of this decision β many of them protest because they don't want many colored houses on the capital's main street. That's why it is decided to use the minimal possible number of colors. The houses don't have to be painted consecutively, but every one of n houses should be painted some color. The one-colored houses should not stand consecutively, any way of painting is acceptable.
There are no more than 5 hours left before the start of painting, help the government find the way when the sum of house numbers for every color is a prime number and the number of used colors is minimal.
Input
The single input line contains an integer n (2 β€ n β€ 6000) β the number of houses on the main streets of the capital.
Output
Print the sequence of n numbers, where the i-th number stands for the number of color for house number i. Number the colors consecutively starting from 1. Any painting order is allowed. If there are several solutions to that problem, print any of them. If there's no such way of painting print the single number -1.
Examples
Input
8
Output
1 2 2 1 1 1 1 2
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_33961 | {
"difficulty": "13",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "8",
"output": "1 1 1 1 2 1 1 1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n",
"output": "1 1 2 1\n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 483_A. Counterexample | Solve the following coding problem using the programming language python:
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l β€ a < b < c β€ r.
More specifically, you need to find three numbers (a, b, c), such that l β€ a < b < c β€ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 β€ l β€ r β€ 1018; r - l β€ 50).
Output
Print three positive space-separated integers a, b, c β three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
s, e = [int(num) for num in input().split()]
def GCD(a, b):
return GCD(b, a % b) if b else a
result = -1
for i in range(s, e + 1):
for j in range(i + 1, e + 1):
if GCD(i, j) == 1:
for k in range(j + 1, e + 1):
if GCD(j, k) == 1 and GCD(i, k) != 1:
print(i, j, k)
result = 0
break
if not result:
break
if not result:
break
if result:
print(result)
``` | vfc_33965 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "900000000000000009 900000000000000029\n",
"output": "900000000000000010 900000000000000011 900000000000000012\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 507_A. Amr and Music | Solve the following coding problem using the programming language python:
Amr is a young coder who likes music a lot. He always wanted to learn how to play music but he was busy coding so he got an idea.
Amr has n instruments, it takes ai days to learn i-th instrument. Being busy, Amr dedicated k days to learn how to play the maximum possible number of instruments.
Amr asked for your help to distribute his free days between instruments so that he can achieve his goal.
Input
The first line contains two numbers n, k (1 β€ n β€ 100, 0 β€ k β€ 10 000), the number of instruments and number of days respectively.
The second line contains n integers ai (1 β€ ai β€ 100), representing number of days required to learn the i-th instrument.
Output
In the first line output one integer m representing the maximum number of instruments Amr can learn.
In the second line output m space-separated integers: the indices of instruments to be learnt. You may output indices in any order.
if there are multiple optimal solutions output any. It is not necessary to use all days for studying.
Examples
Input
4 10
4 3 1 2
Output
4
1 2 3 4
Input
5 6
4 3 1 1 2
Output
3
1 3 4
Input
1 3
4
Output
0
Note
In the first test Amr can learn all 4 instruments.
In the second test other possible solutions are: {2, 3, 5} or {3, 4, 5}.
In the third test Amr doesn't have enough time to learn the only presented instrument.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
I = lambda: map(int, input().split())
n, k = I()
l = sorted(zip(I(), range(1, n+1)))
h = []
for i, j in l:
k -= i
if k>=0: h.append(j)
print(len(h));print(*h)
``` | vfc_33969 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5 6\n4 3 1 1 2\n",
"output": "3\n3 4 5 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 3\n4\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 10\n4 3 1 2\n",
"output": "4\n3 4 2 1 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 100\n100 100\n",
"output": "1\n1 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 49\n16 13 7 2 1\n",
"output": "5\n5 4 3 2 1 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "99 10000\n42 88 21 63 59 38 23 100 86 37 57 86 11 22 19 89 6 19 15 64 18 77 83 29 14 26 80 73 8 51 14 19 9 98 81 96 47 77 22 19 86 71 91 61 84 8 80 28 6 25 33 95 96 21 57 92 96 57 31 88 38 32 70 19 25 67 29 78 18 90 37 50 62 33 49 16 47 39 9 33 88 69 69 29 14 66 75 76 41 98 40 52 65 25 33 47 39 24 80\n",
"output": "99\n17 49 29 46 33 79 13 25 31 85 19 76 21 69 15 18 32 40 64 3 54 14 39 7 98 50 65 94 26 48 24 67 84 59 62 51 74 80 95 10 71 6 61 78 97 91 89 1 37 77 96 75 72 30 92 11 55 58 5 44 73 4 20 93 86 66 82 83 63 42 28 87 88 22 38 68 27 47 99 35 23 45 9 12 41 2 60 81 16 70 43 56 52 36 53 57 34 90 8 ",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 530_B. String inside out | Solve the following coding problem using the programming language python:
You are given a string S of even length s1..s2n . Perform the following manipulations:
* divide it into two halves s1..sn and sn + 1..s2n
* reverse each of them sn..s1 and s2n..sn + 1
* concatenate the resulting strings into sn..s1s2n..sn + 1
Output the result of these manipulations.
Input
The only line of the input contains a string of lowercase Latin letters. The length of the string is between 2 and 20, inclusive, and it is even.
Output
Output the string which is the result of the described manipulations.
Examples
Input
codeforces
Output
fedocsecro
Input
qwertyasdfgh
Output
ytrewqhgfdsa
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_33973 | {
"difficulty": "8",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "codeforces\n",
"output": "fedocsecro\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "qwertyasdfgh\n",
"output": "ytrewqhgfdsa\n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 556_B. Case of Fake Numbers | Solve the following coding problem using the programming language python:
Andrewid the Android is a galaxy-famous detective. He is now investigating a case of frauds who make fake copies of the famous Stolp's gears, puzzles that are as famous as the Rubik's cube once was.
Its most important components are a button and a line of n similar gears. Each gear has n teeth containing all numbers from 0 to n - 1 in the counter-clockwise order. When you push a button, the first gear rotates clockwise, then the second gear rotates counter-clockwise, the the third gear rotates clockwise an so on.
Besides, each gear has exactly one active tooth. When a gear turns, a new active tooth is the one following after the current active tooth according to the direction of the rotation. For example, if n = 5, and the active tooth is the one containing number 0, then clockwise rotation makes the tooth with number 1 active, or the counter-clockwise rotating makes the tooth number 4 active.
Andrewid remembers that the real puzzle has the following property: you can push the button multiple times in such a way that in the end the numbers on the active teeth of the gears from first to last form sequence 0, 1, 2, ..., n - 1. Write a program that determines whether the given puzzle is real or fake.
Input
The first line contains integer n (1 β€ n β€ 1000) β the number of gears.
The second line contains n digits a1, a2, ..., an (0 β€ ai β€ n - 1) β the sequence of active teeth: the active tooth of the i-th gear contains number ai.
Output
In a single line print "Yes" (without the quotes), if the given Stolp's gears puzzle is real, and "No" (without the quotes) otherwise.
Examples
Input
3
1 0 0
Output
Yes
Input
5
4 2 1 4 3
Output
Yes
Input
4
0 2 3 1
Output
No
Note
In the first sample test when you push the button for the first time, the sequence of active teeth will be 2 2 1, when you push it for the second time, you get 0 1 2.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import functools as ft
if __name__ == '__main__':
n = int(input())
a = list(map(int, input().split()))
b = [i for i in range(n)]
for i in range(1, n + 1):
a = [(a[j] + 1) % n if not j % 2 else (a[j] - 1) % n for j in range(n)]
cnt = ft.reduce(lambda x, y: x + y, [a[j] == b[j] for j in range(n)])
if cnt == n:
print("YES")
break
else:
print("NO")
``` | vfc_33977 | {
"difficulty": "8",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n0 2 3 1\n",
"output": "No\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n4 2 1 4 3\n",
"output": "Yes\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n1 0 0\n",
"output": "Yes\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 603_E. Pastoral Oddities | Solve the following coding problem using the programming language python:
In the land of Bovinia there are n pastures, but no paths connecting the pastures. Of course, this is a terrible situation, so Kevin Sun is planning to rectify it by constructing m undirected paths connecting pairs of distinct pastures. To make transportation more efficient, he also plans to pave some of these new paths.
Kevin is very particular about certain aspects of path-paving. Since he loves odd numbers, he wants each pasture to have an odd number of paved paths connected to it. Thus we call a paving sunny if each pasture is incident to an odd number of paved paths. He also enjoys short paths more than long paths, so he would like the longest paved path to be as short as possible. After adding each path, Kevin wants to know if a sunny paving exists for the paths of Bovinia, and if at least one does, the minimum possible length of the longest path in such a paving. Note that "longest path" here means maximum-weight edge.
Input
The first line contains two integers n (2 β€ n β€ 100 000) and m (1 β€ m β€ 300 000), denoting the number of pastures and paths, respectively. The next m lines each contain three integers ai, bi and li, describing the i-th path. The i-th path connects pastures ai and bi (1 β€ ai, bi β€ n; ai β bi) and has length li (1 β€ li β€ 109). Paths are given in the order in which they are constructed.
Output
Output m lines. The i-th line should contain a single integer denoting the minimum possible length of the longest path (maximum-weight edge) in a sunny paving using only the first i paths. If Kevin cannot pave a set of paths so that each pasture is incident to an odd number of paved paths, output - 1.
Note that the paving is only hypotheticalβyour answer after adding the i-th path should not be affected by any of your previous answers.
Examples
Input
4 4
1 3 4
2 4 8
1 2 2
3 4 3
Output
-1
8
8
3
Input
3 2
1 2 3
2 3 4
Output
-1
-1
Input
4 10
2 1 987
3 2 829
4 1 768
4 2 608
3 4 593
3 2 488
4 2 334
2 1 204
1 3 114
1 4 39
Output
-1
-1
829
829
768
768
768
488
334
204
Note
For the first sample, these are the paths that Kevin should pave after building the i-th path:
1. No set of paths works.
2. Paths 1 (length 4) and 2 (length 8).
3. Paths 1 (length 4) and 2 (length 8).
4. Paths 3 (length 2) and 4 (length 3).
In the second sample, there never exists a paving that makes Kevin happy.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_33985 | {
"difficulty": "11",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 4, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 4\n1 3 4\n2 4 8\n1 2 2\n3 4 3\n",
"output": "-1\n8\n8\n3\n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 626_C. Block Towers | Solve the following coding problem using the programming language python:
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students donβt want to use too many blocks, but they also want to be unique, so no two studentsβ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 β€ n, m β€ 1 000 000, n + m > 0) β the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
n, m = map(int, input().split())
x = max(n*2, m*3)
while x//2+x//3-x//6 < m+n:
x += 1
print(x)
``` | vfc_33989 | {
"difficulty": "9",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 2\n",
"output": "8\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 650_A. Watchmen | Solve the following coding problem using the programming language python:
Watchmen are in a danger and Doctor Manhattan together with his friend Daniel Dreiberg should warn them as soon as possible. There are n watchmen on a plane, the i-th watchman is located at point (xi, yi).
They need to arrange a plan, but there are some difficulties on their way. As you know, Doctor Manhattan considers the distance between watchmen i and j to be |xi - xj| + |yi - yj|. Daniel, as an ordinary person, calculates the distance using the formula <image>.
The success of the operation relies on the number of pairs (i, j) (1 β€ i < j β€ n), such that the distance between watchman i and watchmen j calculated by Doctor Manhattan is equal to the distance between them calculated by Daniel. You were asked to compute the number of such pairs.
Input
The first line of the input contains the single integer n (1 β€ n β€ 200 000) β the number of watchmen.
Each of the following n lines contains two integers xi and yi (|xi|, |yi| β€ 109).
Some positions may coincide.
Output
Print the number of pairs of watchmen such that the distance between them calculated by Doctor Manhattan is equal to the distance calculated by Daniel.
Examples
Input
3
1 1
7 5
1 5
Output
2
Input
6
0 0
0 1
0 2
-1 1
0 1
1 1
Output
11
Note
In the first sample, the distance between watchman 1 and watchman 2 is equal to |1 - 7| + |1 - 5| = 10 for Doctor Manhattan and <image> for Daniel. For pairs (1, 1), (1, 5) and (7, 5), (1, 5) Doctor Manhattan and Daniel will calculate the same distances.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import collections
r=0;a,b,c=[collections.Counter() for _ in [0,0,0]]
for _ in range(int(input())):
x,y=map(int, input().split())
r+=a[x]+b[y]-c[(x,y)]
a[x]+=1;b[y]+=1;c[(x,y)]+=1
print(r)
``` | vfc_33993 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 3, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n1 1\n7 5\n1 5\n",
"output": "2",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\n0 0\n0 1\n0 2\n-1 1\n0 1\n1 1\n",
"output": "11",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1 0\n0 19990213\n",
"output": "0",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n46 -55\n46 45\n46 45\n83 -55\n46 45\n83 -55\n46 45\n83 45\n83 45\n46 -55\n",
"output": "33",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 675_D. Tree Construction | Solve the following coding problem using the programming language python:
During the programming classes Vasya was assigned a difficult problem. However, he doesn't know how to code and was unable to find the solution in the Internet, so he asks you to help.
You are given a sequence a, consisting of n distinct integers, that is used to construct the binary search tree. Below is the formal description of the construction process.
1. First element a_1 becomes the root of the tree.
2. Elements a_2, a_3, β¦, a_n are added one by one. To add element a_i one needs to traverse the tree starting from the root and using the following rules:
1. The pointer to the current node is set to the root.
2. If a_i is greater than the value in the current node, then its right child becomes the current node. Otherwise, the left child of the current node becomes the new current node.
3. If at some point there is no required child, the new node is created, it is assigned value a_i and becomes the corresponding child of the current node.
Input
The first line of the input contains a single integer n (2 β€ n β€ 100 000) β the length of the sequence a.
The second line contains n distinct integers a_i (1 β€ a_i β€ 10^9) β the sequence a itself.
Output
Output n - 1 integers. For all i > 1 print the value written in the node that is the parent of the node with value a_i in it.
Examples
Input
3
1 2 3
Output
1 2
Input
5
4 2 3 1 6
Output
4 2 2 4
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
__author__ = "House"
import bisect
if __name__ == "__main__":
n = int(input())
s = [int(i) for i in input().split()]
f = [[s[0], 0]]
outp = list()
for i in range(1, n):
now = [s[i], i]
idx = bisect.bisect_left(f, now)
ans = 0
if idx == 0:
ans = f[0][0]
elif idx == i:
ans = f[idx - 1][0]
else:
if f[idx][1] < f[idx - 1][1]:
ans = f[idx - 1][0]
else:
ans = f[idx][0]
f[idx:idx] = [now]
outp.append(str(ans))
print(" ".join(outp))
``` | vfc_33997 | {
"difficulty": "10",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n4 2 3 1 6\n",
"output": "4 2 2 4 ",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 720_B. Cactusophobia | Solve the following coding problem using the programming language python:
Tree is a connected undirected graph that has no cycles. Edge cactus is a connected undirected graph without loops and parallel edges, such that each edge belongs to at most one cycle.
Vasya has an edge cactus, each edge of this graph has some color.
Vasya would like to remove the minimal number of edges in such way that his cactus turned to a tree. Vasya wants to make it in such a way that there were edges of as many different colors in the resulting tree, as possible. Help him to find how many different colors can the resulting tree have.
Input
The first line contains two integers: n, m (2 β€ n β€ 10 000) β the number of vertices and the number of edges in Vasya's graph, respectively.
The following m lines contain three integers each: u, v, c (1 β€ u, v β€ n, u β v, 1 β€ c β€ m) β the numbers of vertices connected by the corresponding edge, and its color. It is guaranteed that the described graph is indeed an edge cactus.
Output
Output one integer: the maximal number of different colors that the resulting tree can have.
Examples
Input
4 4
1 2 4
2 3 1
3 4 2
4 2 3
Output
3
Input
7 9
1 2 1
2 3 4
3 1 5
1 4 5
4 5 2
5 1 6
1 6 4
6 7 6
7 1 3
Output
6
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_34005 | {
"difficulty": "8",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 4\n1 2 4\n2 3 1\n3 4 2\n4 2 3\n",
"output": "3\n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 741_D. Arpaβs letter-marked tree and Mehrdadβs Dokhtar-kosh paths | Solve the following coding problem using the programming language python:
Just in case somebody missed it: we have wonderful girls in Arpaβs land.
Arpa has a rooted tree (connected acyclic graph) consisting of n vertices. The vertices are numbered 1 through n, the vertex 1 is the root. There is a letter written on each edge of this tree. Mehrdad is a fan of Dokhtar-kosh things. He call a string Dokhtar-kosh, if we can shuffle the characters in string such that it becomes palindrome.
<image>
He asks Arpa, for each vertex v, what is the length of the longest simple path in subtree of v that form a Dokhtar-kosh string.
Input
The first line contains integer n (1 β€ n β€ 5Β·105) β the number of vertices in the tree.
(n - 1) lines follow, the i-th of them contain an integer pi + 1 and a letter ci + 1 (1 β€ pi + 1 β€ i, ci + 1 is lowercase English letter, between a and v, inclusively), that mean that there is an edge between nodes pi + 1 and i + 1 and there is a letter ci + 1 written on this edge.
Output
Print n integers. The i-th of them should be the length of the longest simple path in subtree of the i-th vertex that form a Dokhtar-kosh string.
Examples
Input
4
1 s
2 a
3 s
Output
3 1 1 0
Input
5
1 a
2 h
1 a
4 h
Output
4 1 0 1 0
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_34009 | {
"difficulty": "10",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 3, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n1 s\n2 a\n3 s\n",
"output": "3 1 1 0 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n1 a\n2 h\n1 a\n4 h\n",
"output": "4 1 0 1 0 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n1 b\n2 a\n3 b\n4 d\n5 d\n5 b\n7 d\n5 d\n1 b\n",
"output": "7 5 4 3 3 0 1 0 0 0 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n1 d\n2 b\n3 e\n2 d\n3 d\n4 a\n2 a\n7 b\n9 a\n",
"output": "5 5 3 3 0 0 1 0 1 0 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n1 d\n1 d\n2 d\n3 e\n1 d\n1 d\n2 b\n7 e\n4 c\n",
"output": "4 1 1 1 0 0 1 0 0 0 \n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 765_C. Table Tennis Game 2 | Solve the following coding problem using the programming language python:
Misha and Vanya have played several table tennis sets. Each set consists of several serves, each serve is won by one of the players, he receives one point and the loser receives nothing. Once one of the players scores exactly k points, the score is reset and a new set begins.
Across all the sets Misha scored a points in total, and Vanya scored b points. Given this information, determine the maximum number of sets they could have played, or that the situation is impossible.
Note that the game consisted of several complete sets.
Input
The first line contains three space-separated integers k, a and b (1 β€ k β€ 109, 0 β€ a, b β€ 109, a + b > 0).
Output
If the situation is impossible, print a single number -1. Otherwise, print the maximum possible number of sets.
Examples
Input
11 11 5
Output
1
Input
11 2 3
Output
-1
Note
Note that the rules of the game in this problem differ from the real table tennis game, for example, the rule of "balance" (the winning player has to be at least two points ahead to win a set) has no power within the present problem.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
""" Created by Henrikh Kantuni on 2/14/17 """
if __name__ == '__main__':
k, a, b = [int(x) for x in input().split()]
score_a = 0
if a >= k:
score_a = a // k
score_b = 0
if b >= k:
score_b = b // k
if score_a == 0 and score_b == 0:
print(-1)
else:
if score_a == 0 and score_b > 0:
if b % k == 0:
print(score_b)
else:
print(-1)
elif score_a > 0 and score_b == 0:
if a % k == 0:
print(score_a)
else:
print(-1)
else:
print(score_a + score_b)
``` | vfc_34013 | {
"difficulty": "9",
"memory_limit": null,
"memory_limit_bytes": 512000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "11 2 3\n",
"output": "-1",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "11 11 5\n",
"output": "1",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "18 11 21\n",
"output": "-1",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6 5 7\n",
"output": "-1",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "9 8 17\n",
"output": "-1",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 788_E. New task | Solve the following coding problem using the programming language python:
On the 228-th international Uzhlyandian Wars strategic game tournament teams from each country are called. The teams should consist of 5 participants.
The team of Uzhlyandia will consist of soldiers, because there are no gamers.
Masha is a new minister of defense and gaming. The prime duty of the minister is to calculate the efficiency of the Uzhlandian army. The army consists of n soldiers standing in a row, enumerated from 1 to n. For each soldier we know his skill in Uzhlyandian Wars: the i-th soldier's skill is ai.
It was decided that the team will consist of three players and two assistants. The skills of players should be same, and the assistants' skills should not be greater than the players' skill. Moreover, it is important for Masha that one of the assistants should stand in the row to the left of the players, and the other one should stand in the row to the right of the players. Formally, a team is five soldiers with indexes i, j, k, l, p, such that 1 β€ i < j < k < l < p β€ n and ai β€ aj = ak = al β₯ ap.
The efficiency of the army is the number of different teams Masha can choose. Two teams are considered different if there is such i such that the i-th soldier is a member of one team, but not a member of the other team.
Initially, all players are able to be players. For some reasons, sometimes some soldiers become unable to be players. Sometimes some soldiers, that were unable to be players, become able to be players. At any time any soldier is able to be an assistant. Masha wants to control the efficiency of the army, so she asked you to tell her the number of different possible teams modulo 1000000007 (109 + 7) after each change.
Input
The first line contains single integer n (1 β€ n β€ 105) β the number of soldiers in Uzhlyandia.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 109) β the soldiers' skills.
The third line contains single integer m (1 β€ m β€ 105) β the number of changes.
The next m lines contain the changes, each change is described with two integers t and x (1 β€ t β€ 2, 1 β€ x β€ n) on a separate line. If t = 1, then the x-th soldier is unable to be a player after this change. If t = 2, then the x-th soldier is able to be a player after this change.
It is guaranteed that before each query of the first type the soldier is able to be a player, and before each query of the second type the soldier is unable to be a player.
Output
Print m integers β the number of distinct teams after each change.
Print the answers modulo 1000000007 (109 + 7).
Examples
Input
6
1 1 1 1 1 1
2
1 3
2 3
Output
1
6
Input
8
3 4 4 2 4 5 4 1
3
1 5
2 5
1 2
Output
1
6
2
Note
In the first example, after the first change the only team consists of soldiers [1, 2, 4, 5, 6]. After the second change any five soldiers can form a team.
In the first example after the first change the only team is soldiers [1, 2, 3, 7, 8]. After the second change the possible teams are: [1, 2, 3, 5, 7], [1, 2, 3, 5, 8], [1, 2, 3, 7, 8], [1, 2, 5, 7, 8], [1, 3, 5, 7, 8], [2, 3, 5, 7, 8]. After the third change the possible teams are: [1, 3, 5, 7, 8], [2, 3, 5, 7, 8].
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_34017 | {
"difficulty": "11",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 3, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6\n1 1 1 1 1 1\n2\n1 3\n2 3\n",
"output": "1\n6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "8\n3 4 4 2 4 5 4 1\n3\n1 5\n2 5\n1 2\n",
"output": "1\n6\n2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "30\n93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652 93652\n10\n1 20\n1 19\n1 12\n1 25\n1 29\n1 2\n1 28\n2 28\n2 20\n1 16\n",
"output": "122841\n104820\n88100\n78645\n76498\n74079\n70385\n74079\n87955\n72623\n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 80_B. Depression | Solve the following coding problem using the programming language python:
Do you remember a kind cartoon "Beauty and the Beast"? No, no, there was no firing from machine guns or radiation mutants time-travels!
There was a beauty named Belle. Once she had violated the Beast's order and visited the West Wing. After that she was banished from the castle...
Everybody was upset. The beautiful Belle was upset, so was the Beast, so was Lumiere the candlestick. But the worst thing was that Cogsworth was upset. Cogsworth is not a human, but is the mantel clock, which was often used as an alarm clock.
Due to Cogsworth's frustration all the inhabitants of the castle were in trouble: now they could not determine when it was time to drink morning tea, and when it was time for an evening stroll.
Fortunately, deep in the basement are lying digital clock showing the time in the format HH:MM. Now the residents of the castle face a difficult task. They should turn Cogsworth's hour and minute mustache hands in such a way, that Cogsworth began to show the correct time. Moreover they need to find turn angles in degrees for each mustache hands. The initial time showed by Cogsworth is 12:00.
You can only rotate the hands forward, that is, as is shown in the picture:
<image>
As since there are many ways too select such angles because of full rotations, choose the smallest angles in the right (non-negative) direction.
Note that Cogsworth's hour and minute mustache hands move evenly and continuously. Hands are moving independently, so when turning one hand the other hand remains standing still.
Input
The only line of input contains current time according to the digital clock, formatted as HH:MM (00 β€ HH β€ 23, 00 β€ MM β€ 59). The mantel clock initially shows 12:00.
Pretests contain times of the beginning of some morning TV programs of the Channel One Russia.
Output
Print two numbers x and y β the angles of turning the hour and minute hands, respectively (0 β€ x, y < 360). The absolute or relative error in the answer should not exceed 10 - 9.
Examples
Input
12:00
Output
0 0
Input
04:30
Output
135 180
Input
08:17
Output
248.5 102
Note
A note to the second example: the hour hand will be positioned exactly in the middle, between 4 and 5.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
#
# solving:
# from: https://vjudge.net/contest/417235#problem/D
def main():
inlist = input().split(":")
hh, mm = int(inlist[0]), int(inlist[1])
deg_per_h = 360/12
deg_per_m = 360/60
print("{} {}".format(((hh+mm/60) * deg_per_h) % 360, (mm * deg_per_m) % 360))
main()
``` | vfc_34021 | {
"difficulty": "8",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "04:30\n",
"output": "135 180\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "08:17\n",
"output": "248.5 102\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 834_E. Ever-Hungry Krakozyabra | Solve the following coding problem using the programming language python:
<image>
Recently, a wild Krakozyabra appeared at Jelly Castle. It is, truth to be said, always eager to have something for dinner.
Its favorite meal is natural numbers (typically served with honey sauce), or, to be more precise, the zeros in their corresponding decimal representations. As for other digits, Krakozyabra dislikes them; moreover, they often cause it indigestion! So, as a necessary precaution, Krakozyabra prefers to sort the digits of a number in non-descending order before proceeding to feast. Then, the leading zeros of the resulting number are eaten and the remaining part is discarded as an inedible tail.
For example, if Krakozyabra is to have the number 57040 for dinner, its inedible tail would be the number 457.
Slastyona is not really fond of the idea of Krakozyabra living in her castle. Hovewer, her natural hospitality prevents her from leaving her guest without food. Slastyona has a range of natural numbers from L to R, which she is going to feed the guest with. Help her determine how many distinct inedible tails are going to be discarded by Krakozyabra by the end of the dinner.
Input
In the first and only string, the numbers L and R are given β the boundaries of the range (1 β€ L β€ R β€ 1018).
Output
Output the sole number β the answer for the problem.
Examples
Input
1 10
Output
9
Input
40 57
Output
17
Input
157 165
Output
9
Note
In the first sample case, the inedible tails are the numbers from 1 to 9. Note that 10 and 1 have the same inedible tail β the number 1.
In the second sample case, each number has a unique inedible tail, except for the pair 45, 54. The answer to this sample case is going to be (57 - 40 + 1) - 1 = 17.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_34025 | {
"difficulty": "11",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "1 10\n",
"output": "9",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "40 57\n",
"output": "17",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "157 165\n",
"output": "9",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 855_C. Helga Hufflepuff's Cup | Solve the following coding problem using the programming language python:
Harry, Ron and Hermione have figured out that Helga Hufflepuff's cup is a horcrux. Through her encounter with Bellatrix Lestrange, Hermione came to know that the cup is present in Bellatrix's family vault in Gringott's Wizarding Bank.
The Wizarding bank is in the form of a tree with total n vaults where each vault has some type, denoted by a number between 1 to m. A tree is an undirected connected graph with no cycles.
The vaults with the highest security are of type k, and all vaults of type k have the highest security.
There can be at most x vaults of highest security.
Also, if a vault is of the highest security, its adjacent vaults are guaranteed to not be of the highest security and their type is guaranteed to be less than k.
Harry wants to consider every possibility so that he can easily find the best path to reach Bellatrix's vault. So, you have to tell him, given the tree structure of Gringotts, the number of possible ways of giving each vault a type such that the above conditions hold.
Input
The first line of input contains two space separated integers, n and m β the number of vaults and the number of different vault types possible. (1 β€ n β€ 105, 1 β€ m β€ 109).
Each of the next n - 1 lines contain two space separated integers ui and vi (1 β€ ui, vi β€ n) representing the i-th edge, which shows there is a path between the two vaults ui and vi. It is guaranteed that the given graph is a tree.
The last line of input contains two integers k and x (1 β€ k β€ m, 1 β€ x β€ 10), the type of the highest security vault and the maximum possible number of vaults of highest security.
Output
Output a single integer, the number of ways of giving each vault a type following the conditions modulo 109 + 7.
Examples
Input
4 2
1 2
2 3
1 4
1 2
Output
1
Input
3 3
1 2
1 3
2 1
Output
13
Input
3 1
1 2
1 3
1 1
Output
0
Note
In test case 1, we cannot have any vault of the highest security as its type is 1 implying that its adjacent vaults would have to have a vault type less than 1, which is not allowed. Thus, there is only one possible combination, in which all the vaults have type 2.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import os
import sys
from atexit import register
from io import BytesIO
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip('\r\n')
raw_input = lambda: sys.stdin.readline().rstrip('\r\n')
n,m = map(int,raw_input().split(" "))
mod = int(1e9+7)
edges = [[]for i in range(n+1)]
for i in range(n-1):
u,v = map(int,raw_input().split(" "))
edges[v].append(u)
edges[u].append(v)
cnt,x = map(int,raw_input().split(" "))
dp = [ [0]*33 for i in range(n+1)]
q = [1]
visited= [0]*(1+n)
visited[1] = 1
i = 0
rank = [0]*(n+1)
rank[1] = 1
while i < n:
v = q[i]
for node in edges[v]:
if not visited[node]:
q.append(node)
visited[node] = 1
rank[node] = rank[v]+1
i += 1
tmp = [0]*33
for v in q[::-1]:
f = dp[v]
f[0] = cnt-1
f[12] = 1
f[22] = m-cnt
for son in edges[v]:
if rank[son] < rank[v]:
continue
for i in range(33):
tmp[i] = f[i]
g = dp[son]
for j in range(x+1):
for i in range(x-j+1):
if j == 0:
k = 0
f[k*11+i+j] = ((g[j]+g[11+j]+g[22+j])*tmp[k*11+i] )%mod
k = 1
f[k*11+i+j] = (g[j]*tmp[k*11+i] )%mod
k = 2
f[k*11+i+j] = ((g[j]+dp[son][k*11+j])*tmp[k*11+i] )%mod
else:
k = 0
f[k*11+i+j] = (f[k*11+i+j]+(g[j]+g[11+j]+g[22+j])*tmp[k*11+i] )%mod
k = 1
f[k*11+i+j] = (f[k*11+i+j]+g[j]*tmp[k*11+i] )%mod
k = 2
f[k*11+i+j] = (f[k*11+i+j]+(g[j]+g[k*11+j])*tmp[k*11+i] )%mod
#print v,k*11+i+j,dp[v][k*11+i+j]
print (sum(dp[v][:x+1])+sum(dp[v][11:11+x+1])+sum(dp[v][22:22+x+1]))%mod
``` | vfc_34029 | {
"difficulty": "9",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 1\n1 2\n1 3\n1 1\n",
"output": "0",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 3\n1 2\n1 3\n2 1\n",
"output": "13",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 2\n1 2\n2 3\n1 4\n1 2\n",
"output": "1",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 87_A. Trains | Solve the following coding problem using the programming language python:
Vasya the programmer lives in the middle of the Programming subway branch. He has two girlfriends: Dasha and Masha, who live at the different ends of the branch, each one is unaware of the other one's existence.
When Vasya has some free time, he goes to one of his girlfriends. He descends into the subway at some time, waits the first train to come and rides on it to the end of the branch to the corresponding girl. However, the trains run with different frequencies: a train goes to Dasha's direction every a minutes, but a train goes to Masha's direction every b minutes. If two trains approach at the same time, Vasya goes toward the direction with the lower frequency of going trains, that is, to the girl, to whose directions the trains go less frequently (see the note to the third sample).
We know that the trains begin to go simultaneously before Vasya appears. That is the train schedule is such that there exists a moment of time when the two trains arrive simultaneously.
Help Vasya count to which girlfriend he will go more often.
Input
The first line contains two integers a and b (a β b, 1 β€ a, b β€ 106).
Output
Print "Dasha" if Vasya will go to Dasha more frequently, "Masha" if he will go to Masha more frequently, or "Equal" if he will go to both girlfriends with the same frequency.
Examples
Input
3 7
Output
Dasha
Input
5 3
Output
Masha
Input
2 3
Output
Equal
Note
Let's take a look at the third sample. Let the trains start to go at the zero moment of time. It is clear that the moments of the trains' arrival will be periodic with period 6. That's why it is enough to show that if Vasya descends to the subway at a moment of time inside the interval (0, 6], he will go to both girls equally often.
If he descends to the subway at a moment of time from 0 to 2, he leaves for Dasha on the train that arrives by the second minute.
If he descends to the subway at a moment of time from 2 to 3, he leaves for Masha on the train that arrives by the third minute.
If he descends to the subway at a moment of time from 3 to 4, he leaves for Dasha on the train that arrives by the fourth minute.
If he descends to the subway at a moment of time from 4 to 6, he waits for both trains to arrive by the sixth minute and goes to Masha as trains go less often in Masha's direction.
In sum Masha and Dasha get equal time β three minutes for each one, thus, Vasya will go to both girlfriends equally often.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
a,b=map(int,input().split())
if(a==b):
print('Equal')
exit()
import math
lcm=(a*b)//(math.gcd(a,b))
if(a<b):
da=(lcm//a)-1
ma=lcm//b
if(da>ma):
print('Dasha')
elif(da<ma):
print('Masha')
else:
print('Equal')
else:
da=(lcm//a)
ma=(lcm//b)-1
if(da>ma):
print('Dasha')
elif(da<ma):
print('Masha')
else:
print('Equal')
``` | vfc_34033 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2 3\n",
"output": "Equal\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 903_C. Boxes Packing | Solve the following coding problem using the programming language python:
Mishka has got n empty boxes. For every i (1 β€ i β€ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 β€ n β€ 5000) β the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
from sys import stdin,stdout
from collections import Counter
def ai(): return list(map(int, stdin.readline().split()))
def ei(): return map(int, stdin.readline().split())
def ip(): return int(stdin.readline().strip())
def op(ans): return stdout.write(str(ans) + '\n')
t = ip()
li = ai()
x = max(li)
c = Counter(li).values()
print(max(c))
``` | vfc_34037 | {
"difficulty": "9",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n1 2 3\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n4 2 4 3\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 925_D. Aztec Catacombs | Solve the following coding problem using the programming language python:
Indiana Jones found ancient Aztec catacombs containing a golden idol. The catacombs consists of n caves. Each pair of caves is connected with a two-way corridor that can be opened or closed. The entrance to the catacombs is in the cave 1, the idol and the exit are in the cave n.
When Indiana goes from a cave x to a cave y using an open corridor, all corridors connected to the cave x change their state: all open corridors become closed, all closed corridors become open. Indiana wants to go from cave 1 to cave n going through as small number of corridors as possible. Help him find the optimal path, or determine that it is impossible to get out of catacombs.
Input
The first line contains two integers n and m (2 β€ n β€ 3β
10^5, 0 β€ m β€ 3 β
10^5) β the number of caves and the number of open corridors at the initial moment.
The next m lines describe the open corridors. The i-th of these lines contains two integers u_i and v_i (1 β€ u_i, v_i β€ n, u_i β v_i) β the caves connected by the i-th open corridor. It is guaranteed that each unordered pair of caves is presented at most once.
Output
If there is a path to exit, in the first line print a single integer k β the minimum number of corridors Indians should pass through (1 β€ k β€ 10^6). In the second line print k+1 integers x_0, β¦, x_k β the number of caves in the order Indiana should visit them. The sequence x_0, β¦, x_k should satisfy the following:
* x_0 = 1, x_k = n;
* for each i from 1 to k the corridor from x_{i - 1} to x_i should be open at the moment Indiana walks along this corridor.
If there is no path, print a single integer -1.
We can show that if there is a path, there is a path consisting of no more than 10^6 corridors.
Examples
Input
4 4
1 2
2 3
1 3
3 4
Output
2
1 3 4
Input
4 2
1 2
2 3
Output
4
1 2 3 1 4
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_34041 | {
"difficulty": "10",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 2\n1 2\n2 3\n",
"output": "4\n1 2 3 1 4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 4\n1 2\n2 3\n1 3\n3 4\n",
"output": "2\n1 3 4 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 2\n2 3\n1 2\n",
"output": "2\n1 2 3 ",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 980_D. Perfect Groups | Solve the following coding problem using the programming language python:
SaMer has written the greatest test case of all time for one of his problems. For a given array of integers, the problem asks to find the minimum number of groups the array can be divided into, such that the product of any pair of integers in the same group is a perfect square.
Each integer must be in exactly one group. However, integers in a group do not necessarily have to be contiguous in the array.
SaMer wishes to create more cases from the test case he already has. His test case has an array A of n integers, and he needs to find the number of contiguous subarrays of A that have an answer to the problem equal to k for each integer k between 1 and n (inclusive).
Input
The first line of input contains a single integer n (1 β€ n β€ 5000), the size of the array.
The second line contains n integers a_1,a_2,...,a_n (-10^8 β€ a_i β€ 10^8), the values of the array.
Output
Output n space-separated integers, the k-th integer should be the number of contiguous subarrays of A that have an answer to the problem equal to k.
Examples
Input
2
5 5
Output
3 0
Input
5
5 -4 2 1 8
Output
5 5 3 2 0
Input
1
0
Output
1
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
#!/usr/bin/env python3
from math import sqrt
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,
101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193,
197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307,
311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421,
431, 433, 439, 443, 449, 457, 461, 463]
psq = [p*p for p in primes]
def sqfree(x):
if x == 0:
return x
y = 1
for p, pp in zip(primes, psq):
while x % pp == 0:
x //= pp
if x % p == 0:
x //= p
y *= p
if abs(x) < p:
break
if int(sqrt(abs(x)))**2 == abs(x):
return (y if x > 0 else -y)
else:
return x * y
n = int(input().strip())
ais = list(map(int, input().strip().split()))
bis = list(map(sqfree, ais))
prev = [-1 for i in range(n)]
last = {}
for i, b in enumerate(bis):
if b in last:
prev[i] = last[b]
last[b] = i
res = [0 for i in range(n)]
for l in range(n):
cnt = 0
for r in range(l, n):
if bis[r] != 0 and prev[r] < l:
cnt += 1
res[max(cnt - 1, 0)] += 1
print (' '.join(map(str, res)))
``` | vfc_34049 | {
"difficulty": "10",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n5 5\n",
"output": "3 0 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n0\n",
"output": "1 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n5 -4 2 1 8\n",
"output": "5 5 3 2 0 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "30\n1 2 0 2 1 0 0 1 2 0 1 2 3 0 4 1 0 0 0 3 2 0 1 0 1 0 5 0 6 0\n",
"output": "77 90 216 42 40 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n2 0\n",
"output": "3 0 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "80\n8861 -8846 -3257 8263 -8045 4549 9626 -8599 5755 -3559 5813 -7411 9151 -1847 2441 4201 2381 4651 -6571 199 -6737 -6333 -9433 -4967 9041 -9319 6801 5813 -2731 -8599 7681 -1303 -7333 6067 -1847 -6333 6047 -7907 -7333 8677 -937 829 2441 -5702 -8045 -3037 -4882 -7703 9001 -5702 -2039 -7493 9173 -6047 6046 5802 -8609 9173 8083 8291 -1453 2381 7321 -859 8539 -2011 2374 8263 8111 -5897 -2017 -2311 -571 4993 -3389 -7789 1847 -4799 4651 -5702\n",
"output": "80 79 78 77 77 78 77 76 75 74 73 72 72 71 70 71 69 68 67 66 68 66 69 64 66 65 63 60 58 57 55 56 52 53 48 48 46 45 44 41 42 42 39 39 36 35 33 33 31 29 28 27 25 26 23 22 25 22 15 16 12 13 9 12 5 4 3 0 0 0 0 0 0 0 0 0 0 0 0 0 ",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 9_D. How many trees? | Solve the following coding problem using the programming language python:
In one very old text file there was written Great Wisdom. This Wisdom was so Great that nobody could decipher it, even Phong β the oldest among the inhabitants of Mainframe. But still he managed to get some information from there. For example, he managed to learn that User launches games for pleasure β and then terrible Game Cubes fall down on the city, bringing death to those modules, who cannot win the game...
For sure, as guard Bob appeared in Mainframe many modules stopped fearing Game Cubes. Because Bob (as he is alive yet) has never been defeated by User, and he always meddles with Game Cubes, because he is programmed to this.
However, unpleasant situations can happen, when a Game Cube falls down on Lost Angles. Because there lives a nasty virus β Hexadecimal, who is... mmm... very strange. And she likes to play very much. So, willy-nilly, Bob has to play with her first, and then with User.
This time Hexadecimal invented the following entertainment: Bob has to leap over binary search trees with n nodes. We should remind you that a binary search tree is a binary tree, each node has a distinct key, for each node the following is true: the left sub-tree of a node contains only nodes with keys less than the node's key, the right sub-tree of a node contains only nodes with keys greater than the node's key. All the keys are different positive integer numbers from 1 to n. Each node of such a tree can have up to two children, or have no children at all (in the case when a node is a leaf).
In Hexadecimal's game all the trees are different, but the height of each is not lower than h. In this problem Β«heightΒ» stands for the maximum amount of nodes on the way from the root to the remotest leaf, the root node and the leaf itself included. When Bob leaps over a tree, it disappears. Bob gets the access to a Cube, when there are no trees left. He knows how many trees he will have to leap over in the worst case. And you?
Input
The input data contains two space-separated positive integer numbers n and h (n β€ 35, h β€ n).
Output
Output one number β the answer to the problem. It is guaranteed that it does not exceed 9Β·1018.
Examples
Input
3 2
Output
5
Input
3 3
Output
4
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
n,h=map(int,input().split())
L=[]
for i in range(n+1):
g=[]
for j in range(n+1):
g.append(0)
L.append(g)
L[0][0]=1
for i in range(1,n+1):
for j in range(1,n+1):
sumu=0
for m in range(1,i+1):
t1=L[m-1][j-1]
tot=0
for k in range(0,j):
tot+=L[i-m][k]
t1*=tot
t2=L[i-m][j-1]
tot=0
for k in range(0,j-1):
tot+=L[m-1][k]
t2*=tot
sumu+=(t1+t2)
L[i][j]=sumu
ans=0
for i in range(h,n+1):
ans+=L[n][i]
print(ans)
``` | vfc_34053 | {
"difficulty": "10",
"memory_limit": null,
"memory_limit_bytes": 64000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 2\n",
"output": "5\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 3\n",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "21 12\n",
"output": "12153990144\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "23 21\n",
"output": "275251200\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | bhargav-and-gre | Solve the following coding problem using the programming language python:
bhargav has dream to study his MS is foreign country. So, He started his preparation for GRE. There are huge number of words that he has to prepare for. So, firs he wanted to group all synonyms and antonyms. As there are huge number of words that he has to group. So, he asked help to group all synonyms and antonyms of a word.
it is called antonym if the first letter of a current number is 3 steps upper than reference then it is antonym if the first letter of the reference number is same as the current first letter of a word then it is synonym. and the length should be same for the antonym and synonym
INPUT:
first line should contain a word W.
next line contains no of words N.
next N lines consists of words that are to be grouped.
OUTPUT
print no of synonyms S followed by antonyms A.
SAMPLE INPUT
hasrfk
4
heyfgs
jhajyrbf
kayufs
hetinf
SAMPLE OUTPUT
2 1
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
s=raw_input()
n=input()
a=0
sy=0
for i in range(n):
s1=raw_input()
if s1[0]==s[0] and len(s1)==len(s):
sy+=1
if chr(ord(s[0])+3)==s1[0] and len(s1)==len(s):
a+=1
print sy,a
``` | vfc_34057 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "hasrfk\n4\nheyfgs\njhajyrbf\nkayufs\nhetinf\n\nSAMPLE",
"output": "2 1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "ashtrick\n25\namberhed\ndouglasb\nashmartin\nroogle\neglownasht\ndutterwo\naverists\ndueglors\naeufahef\neutifhre\naedsrntf\naleifksc\nalejfisj\neshmarin\naksiefjs\ndharanis\nqueofjsl\ndileeeep\nprashant\naravinds\nakhilesh\ndheufncs\najeufjvjs\naeuigvsr\naskhtakuen",
"output": "10 6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "ashtrick\n25\namberhed\ndouglasb\nashmartin\nroogle\neglownasht\ndutterwo\naverists\ndueglors\naeufahef\neutifhre\naedsqntf\naleifksc\nalejfisj\neshmarin\naksiefjs\ndharanis\nqueofjsl\ndileeeep\nprashant\naravinds\nakhilesh\ndheufncs\najeufjvjs\naeuigvsr\naskhtakuen",
"output": "10 6\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | converter | Solve the following coding problem using the programming language python:
Raghu wants to design a converter such that when a user inputs a binary number it gets converted to Octal number & also the correspond alphabet to it.
Example- if a user inputs- 10101101
then the output is 255 BEE
Note : for decimal places there should be a space between the alphabetic signs
Ex- for input 101101101110.111
output -5556.7 EEEF G
A stands for 1, b for 2 , if the octal digit is 0 consider it as a space
SAMPLE INPUT
10101101
SAMPLE OUTPUT
255 BEE
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
bindict = {'000':0,'001':1,'010':2,'100':4,'101':5,'110':6,'111':7,'011':3}
binary = raw_input().split('.')
for index,value in enumerate(binary):
arr = []
if(index==0):
while(len(value)%3!=0):
value='0'+value
j = 1
i = 0
while(j<=len(value)):
if(j%3==0):
arr.append(value[i:j])
i = j
j+=1
total = ''
for k in arr:
total+=str(bindict[k])
if(index==1):
total+='.'
while(len(value)%3!=0):
value=value+'0'
j = 1
i = 0
while(j<=len(value)):
if(j%3==0):
arr.append(value[i:j])
i = j
j+=1
for k in arr:
total+=str(bindict[k])
string = ''
for i in total:
if(i=='.'):
string+=' '
else:
string+=chr(64+int(i))
print total+ ' '+string
``` | vfc_34061 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "10101101\n\nSAMPLE",
"output": "255 BEE",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10101101",
"output": "255 BEE",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10101111",
"output": "257 BEG",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10101101\n\nSAPMLE",
"output": "255 BEE",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "11101101",
"output": "355 CEE",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | find-the-hub | Solve the following coding problem using the programming language python:
After decrypting the code Enigma crew came to know that there are N locations where bombs has been planted. X1, X2 β¦. Xn are the N locations. Among this locations, one X location is the central hub which control all the other Xn-1 location. 1 or more than 1 signal is send to N locations. The decrypted code simplified that the X location is not divisible from the range 2 to X/2.
Your job is to help the Enigma crew by finding the largest X location and how many times it is repeated. So, the Enigma crew can defuse the main hub.
Input Format
The first line contains a single integer, N, representing the number of locations.
In the second line, there are N space-separated integers X1, X2 β¦..Xn, representing the location of N.
Output Format
There will be two line of output.
First line contain the largest X location.
Second line contain the number of times is repeated.
Constraints
1 β€ N β€ 100000
1 β€ X β€ 1000000
SAMPLE INPUT
10
1 3 5 17 21 17 5 11 10 40
SAMPLE OUTPUT
17
2
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
def isPrime(num):
if num == 0 or num == 1:
return False
if num == 2:
return True
if num % 2 == 0:
return False
i = 3
while i <= num**0.5+1:
if num%i == 0:
return False
i = i+2
return True
t = int(raw_input())
Arr = map(int, raw_input().strip().split(' '))
mx = -1
for i in Arr:
#print i, isPrime(i)
if i > mx and isPrime(i):
mx = i
print mx
print Arr.count(mx)
``` | vfc_34065 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "10\n1 3 5 17 21 17 5 11 10 40\n\nSAMPLE",
"output": "17\n2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n1 3 5 17 21 17 5 11 7 40\n\nSAMPLE",
"output": "17\n2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n1 3 5 17 19 17 5 11 1 38\n\nSAMPLE",
"output": "19\n1\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | indexing-the-palindrome | Solve the following coding problem using the programming language python:
You are given a string of lower case letters. Your task is to figure out the index of the character on whose removal it will make the string a palindrome. There will always be a valid solution.
In case the string is already a palindrome, then -1 is also a valid answer along with possible indices.
Input Format
The first line contains T, i.e. the number of test cases.
T lines follow, each containing a string.
Output Format
Print the position (0 index) of the letter by removing which the string turns into a palindrome. For a string, such as bcbc,
we can remove b at index 0 or c at index 3. Both answers are accepted.
Constraints
1β€Tβ€20
1β€ length of string β€10^6
All characters are Latin lower case indexed.
SAMPLE INPUT
3
aaab
baa
aaa
SAMPLE OUTPUT
3
0
-1
Explanation
In the given input, T = 3,
For input aaab, we can see that removing b from the string makes the string a palindrome, hence the position 3.
For input baa, removing b from the string makes the string palindrome, hence the position 0.
As the string aaa is already a palindrome, you can output 0, 1 or 2 as removal of any of the characters still maintains the palindrome property. Or you can print -1 as this is already a palindrome.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
for _ in range(input()):
strn = raw_input().strip()
le = len(strn)
if le < 3:
print "0"
continue
index = 0
f = 1
while index < le / 2:
if strn[index] == strn[-1-index]:
index+=1
else:
f = 0
break
if f == 1:
print "-1"
continue
f = 1
spl = index
while index<le/2:
if strn[index] == strn[-2-index]:
index +=1
else:
f = 0
break
if f == 1:
print le - 1 - spl
else:
print spl
``` | vfc_34069 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\naaab\nbaa\naaa\n\nSAMPLE",
"output": "3\n0\n-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\naaab\nbaa\naaa",
"output": "3\n0\n-1\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | mattey-multiplication-6 | Solve the following coding problem using the programming language python:
Mattey has an assignment that he should submit tomorrow. The assignment has one question which asks to write a program to multiply two numbers without using ''* operator. As Mattey finds no interest in this subject, he never listens to classes and so do not know about shift operators.
He comes to you to learn about this topic. You can explain in any manner you wish. But for this question, given N and M, write an equation using left shift operators whose result will be equal to the product N*M.
Input :
First line has T denoting number of test cases.
Next T lines has two integers N,M.
Output :
For each test case print an equation resembling "(N<< p_1) + (N << p_2) + ... + (N << p_k)" (without quotes) where p_1 β₯ p_2 β₯ ... β₯ p_k and k is minimum.
Constraints :
1 β€ T β€ 5*10 ^ 4
1 β€ N,M β€ 10 ^ 16
SAMPLE INPUT
2
2 1
2 3
SAMPLE OUTPUT
(2<<0)
(2<<1) + (2<<0)
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
T=int(raw_input())
while T>0:
sd=list()
n=list(raw_input().split())
pro=int(n[0])*int(n[1])
c=0
x=int(n[0])
y=int(n[1])
s=x
rem=1
# c=num-1
while y!=0:
te=y%2
sd.extend(str(te))
y=y/2
c=c+1
# print sd[0]
me=0
c=c-1
while c >= 0:
if int(sd[c]) == 1:
if me != 0:
print "+ (%d<<%d)" % (x,c),
else:
print "(%d<<%d)" % (x,c),
me=me+1
c=c-1
print
T=T-1
``` | vfc_34073 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n2 1\n2 3\n\nSAMPLE",
"output": "(2<<0)\n(2<<1) + (2<<0)\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n3 1\n2 3\n\nSAMPLE",
"output": "(3<<0)\n(2<<1) + (2<<0)\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1 1\n2 3\n\nSAMPKE",
"output": "(1<<0)\n(2<<1) + (2<<0)\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n2 1\n2 3\n\nSAMPKE",
"output": "(2<<0)\n(2<<1) + (2<<0)\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n2 1\n2 1\n\nSAMPKE",
"output": "(2<<0)\n(2<<0)\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | om-nom-and-candies | Solve the following coding problem using the programming language python:
There are N boxes .The i^th box contains ai candies . The frog Om Nom is sitting in box number 1 .Om Nom wants to collect as many candies as he can . However , Om Nom jumps in a peculiar fashion . Om Nom can jump from box number j to box number i only if j | i (j divides i) . Whenever Om Nom lands in a box , he collects all the candies in that box. You have to report the maximum number of Candies that Om Nom can collect for all i from 1 to N if i is the last box that Om Nom visits.See the samples for more details.
Constraints
0 β€ ai β€ 100000
1 β€ N β€ 100000
Input
The first line contains the number N.
The second line contains the array a , the i^th integer denoting the number of candies in the i^th box.
Output
Print N integers-the i^th integer should be the maximum number of candies that Om Nom can collect if the i^th box is his final box (i.e his sequence of jumps ends at i).
SAMPLE INPUT
5
2 3 1 4 6
SAMPLE OUTPUT
2 5 3 9 8
Explanation
For i=1,Om Nom stops at box number 1 itself and so he can collect only 2 candies.
For i=2,the sequence of jumps is 1 2(array indices)
For i=3,the sequence of jumps is 1 3
For i=4,the sequence of jumps is 1 2 4
For i=5,the sequence of jumps is 1 5
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import math
n=input()
alist=map(int,raw_input().split())
track=[alist[i]+alist[0] for i in range(n)]
track[0]-=alist[0]
for i in range(2,int(n/2)+2):
x=i+i
while x<=n:
track[x-1]=max(track[x-1],track[i-1]+alist[x-1])
x+=i
for i in track:
print i,
``` | vfc_34077 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n2 3 1 4 6\n\nSAMPLE",
"output": "2 5 3 9 8",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | ram-in-the-hostel-mess-3 | Solve the following coding problem using the programming language python:
Codex is about to start and Ram has not done dinner yet. So, he quickly goes to hostel mess and finds a long queue in front of food counter. But somehow he manages to take the food plate and reaches in front of the queue. The plates are divided into sections such that it has 2 rows and N columns.
Due to the crowd Ram knows that when he will get out of the queue the food will get mixed. So, he don't want to put food in two consecutive sections column wise
but he can put food in two consecutive sections row wise as spacing between the rows is good enough to take food out of the queue safely. If he doesn't like the food, he will not take food. You are given N and you have to tell the number of ways in which food can be taken without getting it mixed.
Input Format:
First line contains T which denotes number of test cases and each test case represents a single line containing the value of N.
Output Format
Output the total ways for each input.
SAMPLE INPUT
2
1
3
SAMPLE OUTPUT
4
25
Explanation
Explanation:
Case 1:
Plate has 2 rows and 1 column each. So, Ram can
Put food in upper section.
Put food in lower section.
Put food in both section.
Do Not food in either section.
Case 2:
Plate has 2 rows and 3 columns. So, possible ways for one row are PNN, PNP, NNN, NPN, NNP where P represents food taken and N represents food not taken.
Total possible ways are 25 because a way to put food in 1 row can correspond
to any of 5 ways on other row.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
from math import factorial
def ncr(n,r):
if(n<0 or r<0):
return 0
elif(n<r):
return 0
else:
return factorial(n)/(factorial(r)*factorial(n-r))
t = input()
for i in range(0,t):
n = input()
ans = 0
p = 1
i = 1
while(p>0):
ans = ans + p
p = ncr(n,i)
n = n - 1
i = i + 1
print ans*ans
``` | vfc_34081 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n1\n3\n\nSAMPLE",
"output": "4\n25\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "19\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19",
"output": "4\n9\n25\n64\n169\n441\n1156\n3025\n7921\n20736\n54289\n142129\n372100\n974169\n2550409\n6677056\n17480761\n45765225\n119814916\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "19\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n18\n17\n18\n19",
"output": "4\n9\n25\n64\n169\n441\n1156\n3025\n7921\n20736\n54289\n142129\n372100\n974169\n2550409\n45765225\n17480761\n45765225\n119814916\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1\n3\n\nSBMPLE",
"output": "4\n25\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "19\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n18\n17\n6\n19",
"output": "4\n9\n25\n64\n169\n441\n1156\n3025\n7921\n20736\n54289\n142129\n372100\n974169\n2550409\n45765225\n17480761\n441\n119814916\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | simple-maths | Solve the following coding problem using the programming language python:
PROBLEM SPECIFICATION:
You are given three positive integers 'n' , 'a' and 'b' . In the given range from 1 to 'n' how many distinct numbers are completely divisible by
'a' or 'b' or both?
NOTE: The range includes both 1 and 'n'.
INPUT SPECIFICATION:
You will be given 't' test cases. Each test case will contain three integers 'n' 'a' and 'b'.
OUTPUT SPECIFICATION:
In a single line print the count of numbers that are divisible by 'a' and 'b'.
CONSTRAINTS:
0<t<100
n<10^15
0 β€ a<10^6
0 β€ b<10^6
NOTE: In case,if 'a' or 'b' or both of them are zero,print '-1' (without quotes).
SAMPLE INPUT
1
24 5 3
SAMPLE OUTPUT
11
Explanation
Here in the given range there are total 11 distinct numbers that are divisible by 5 or 3 or both.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
def lcm(x, y):
if x > y:
greater = x
else:
greater = y
while(True):
if((greater % x == 0) and (greater % y == 0)):
lcm = greater
break
greater += 1
return lcm
t = int(raw_input())
for j in range(t):
c = 0
n,a,b = tuple(map(int,raw_input().split()))
if((a == 0) or ( b == 0)):
print(-1)
else:
c = (int(n/a)) + (int(n/b)) -(int(n/(lcm(a,b))))
print(c)
``` | vfc_34085 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "1\n24 5 3\n\nSAMPLE",
"output": "11\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "11\n24 5 3\n1000000000 1 4\n978654 5467 378\n100000008 2 87965\n989 3 78\n2571 23 890\n12345678 765 987\n2353768 123 998\n87879645 4 7\n12309876 5 8796\n6598354 7658 8",
"output": "11\n1000000000\n2765\n50000572\n329\n113\n28597\n21475\n31385588\n2463095\n825440\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | the-string-monster-july-easy | Solve the following coding problem using the programming language python:
As Gudi escapes the room and moves onto to the next floor, the Wizard of UD receives her at the gate!
The wizard questions her intelligence and does not allow her to move ahead unless she answers his puzzle correctly. The wizard says :
Imagine that you are trapped in a dungeon, little girl . And the gate to the exit is guarded by a Monster. The Monster eats strings. Different strings trigger different behaviors of the monster. You know the string that can make it sleep. However, you do not posses it. All you have are N strings scattered on the floor in the dungeon. You can pick up any subset of these and rearrange the characters to form the required subset. You can't pick up a partial string or discard part of any string that you pick.
Answer me, little girl, can you use these strings to form the string that shall make the monster sleep and get you out alive?
Help Gudi answer the Wizard correctly. The strings on the floor have a maximum size K , and the strings that the monster eats have a maximum size L. Each of these strings consists of only lowercase alphabets [ 'a'-'z' ].
Input
First line contains an integer T. T testcases follow.
First line of each test case contains an integer N. N lines follow.Each of these lines contains a string.
Next line contains the string that shall make the monster sleep.
Output
For each testcase, print the answer i.e. either "YES" (without the quotes) or "NO" (without the quotes), in a new line.
Constraints
1 β€ T β€ 10
1 β€ N β€ 30
1 β€ K β€ 30
1 β€ L β€ 900
SAMPLE INPUT
2
4
hey
rain
day
wet
draaxiny
4
bump
ud
bish
chau
bichhusa
SAMPLE OUTPUT
NO
YES
Explanation
The sleep string for first case "draaxiny" can not be formed.
The sleep string for second case can be formed using the last two strings.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import sys, math, random, operator
#from string import ascii_lowercase
#from string import ascii_uppercase
from fractions import Fraction, gcd
from decimal import Decimal, getcontext
from itertools import product, permutations, combinations
from Queue import Queue, PriorityQueue
from collections import deque, defaultdict, Counter
getcontext().prec = 100
MOD = 10**9 + 7
INF = float("+inf")
if sys.subversion[0] != "CPython": # PyPy?
raw_input = lambda: sys.stdin.readline().rstrip()
pr = lambda *args: sys.stdout.write(" ".join(str(x) for x in args) + "\n")
epr = lambda *args: sys.stderr.write(" ".join(str(x) for x in args) + "\n")
die = lambda *args: pr(*args) ^ exit(0)
read_str = raw_input
read_strs = lambda: raw_input().split()
read_int = lambda: int(raw_input())
read_ints = lambda: map(int, raw_input().split())
read_float = lambda: float(raw_input())
read_floats = lambda: map(float, raw_input().split())
"---------------------------------------------------------------"
ZERO = (0,) * 26
# def finalize(c):
# return tuple(sorted(c.items()))
def getpos(lst):
ans = set()
for l in xrange(0, len(lst)+1):
for ws in combinations(lst, l):
res = [0] * 26
for w in ws:
add(res, w)
ans.add(tuple(res))
return ans
def Counter(s):
res = [0] * 26
for c in s:
res[ord(c)-0x61] += 1
return tuple(res)
def add(c1, c2):
for i in xrange(len(c1)):
c1[i] += c2[i]
t = read_int()
for t in xrange(t):
n = read_int()
lst = []
for i in xrange(n):
lst.append(Counter(read_str()))
target = Counter(read_str())
if target in lst:
print "YES"
continue
if len(lst) == 1:
print "NO"
continue
h = n / 2
pos1 = getpos(lst[:h])
pos2 = getpos(lst[h:])
for cset in pos1:
good = 1
res = list(target)
for i, (a, b) in enumerate(zip(cset, target)):
if a > b:
good = 0
break
res[i] -= a
if not good:
continue
if tuple(res) in pos2:
print "YES"
break
else:
print "NO"
``` | vfc_34089 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n4\nhey\nrain\nday\nwet\ndraaxiny\n4\nbump\nud\nbish\nchau\nbichhusa\n\nSAMPLE",
"output": "NO\nYES",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n12\nwaqacryrawvqtwvvrrrtuwbqcawerb\nacwttywawraetvaweecurquaayvuta\nrcbbuwcqcvtvyucbuyqurwvuttrttc\nvuqvqywawawyubwturcruwryvcawyr\naecaabyyrbayruwyyebtbvqyavyaru\nwttacywubvqueavbcqbuwetqyctcve\ncqcvucqttutqqeqvayatcqwybayubu\nuwcbtuabtubqqwwtaavqbccbbwwcyy\ntwvtweytbqracbrutcqcywqqwbtuvt\nbqarvtrywveuavuvcwqvutrtbwvuyv\nwbbtcbwbybrvvurebeuaycevtbwyuw\nax\nacwttywawraetvaweecurquaayvutarcbbuwcqcvtvyucbuyqurwvuttrttcaecaabyyrbayruwyyebtbvqyavyarua\n13\nuubqqevbqvqcaytyyqvbwcvvaurutv\ncrrbaacvcacarvertvqbctvauvqbvw\nrwcbtuyveacbvtuvybrabuvabaucae\nqtvruurucvccwtqryqvebtretwbqbu\nretrtcewyeybrbuqcctrvcqqutbrvc\nvbqbucuyvcccuvwcyawreuvuabaaaq\nyccwyacycaravuvbabtutqrbvrtyub\nybwbabubvwwbqavueuauawrquvqeqe\nvqebqbvretuaqbcbayuavqtvuyveva\ntwruutcweeectwwecutbqcbavwtrwc\nevrutvcwrtqtayquvuawvttayeccaq\nrubycuyvveqqrrwywtwqvqavbbteaq\nux\nuubqqevbqvqcaytyyqvbwcvvaurutvcrrbaacvcacarvertvqbctvauvqbvwu\n6\nyvabrvevwbuvtqeraeuwrrrytrtuer\neuwqbewywveeebweyuaqbaycuequav\nbeuttybvucyvwrawuwyaycwuytbcva\ncwcbctawccyqqabtvbwqrvwwrcqeva\ntwyvqqqvtaccycwveuuvbceqeqetra\nyx\nyvabrvevwbuvtqeraeuwrrrytrtuery\n15\ncywqeewueveeetcyqbrtbyqewtteay\nuyqbcraqvrryqrqqcyuqyaauwrtbvt\ntwavrabcbvybeburuqqwbycqacyvay\nbweurueeyytvauqtaeryrbwyyybuue\ncrtywevywawbrbqeqtayybwbywryyc\nbwqtvrbbybyyqveuetayectrrvreyu\ntvbwctctayecqrvtywyrqvbqyavwwb\neqveqvrtreyyuabcvcbqrvwtrybque\nevqcqvwettbwruwweabvyruuacaeeu\newvbqruwuqycwrubctcbqewvtvyavr\nrrrvbuvqcyetwqrqrtvrvareyryvvq\nuquceabbcrywquutbrvwvqayrvqbbt\nwccyqvcuyttvrqwewtbateetatyebu\nwreecquwbawureucqauvyabraeqcyt\ncx\ncywqeewueveeetcyqbrtbyqewtteayuyqbcraqvrryqrqqcyuqyaauwrtbvttwavrabcbvybeburuqqwbycqacyvaytvbwctctayecqrvtywyrqvbqyavwwbc\n7\ncturvcqacubvwbtauuqucbvcrvyyvt\nrcavvwatcueercrccetqrcuruqvbey\nvuqqybwataebrqacurtruqyqrabcuv\nttcyuvabaqatbvtwqtevqaetuuyeqv\nbrrubtayqvyqbtbyabyetvuwybcvty\nbybeyeqcrbuarqqqryeywcvucrrbuv\netarqwtybbuyyecrbtcqrbrerwcwbc\nwanibmlsgbwoprezbojygnrzjurfkowoqqorcaeklerxsaixprphipogkuyljzqlqcturwofgidjyfntkbllxyivbvaxgcplxaitrnpaucoaavspxfhcrngsnjzdyhttotkshmphdjdaasokwjyseaosiytdaofibjcaqafkcuxhqoomkdeivrbsycnqzgqqcfkbzuigxirzzaaqsbgbvbfpdigusnlddltujtnhnlxysnfpqflngbkphycvnndkvwfrdjlyhsoocejesrklyjkaxsetypfvglsdyvshunyfxqybgbkcbesettrmycutyeypxvtbhhkzxpllfwxkyzwrcnpzueslpnzapfejoksdfnyuytjzxyhxvbmmfogydtkjwvihnuprjphpgulipesksjpzwzkengnreumemmkycdow\n5\nabcybuwtwqccqwtybeeyeqrywbvtae\nvvuveyeawuuyyycyayawcrtcctuyvb\neaqqwwybqwytebyyeucqbqeuyqrtra\nawybvvrvutbqwvcveycvqqvatecevc\nuwwyeeatqqeeaayaevtyqcwtetbewc\ngltpgaklvrdptobbguurspbbngkjrbtennaewhhgrmyybrveogkvcnfsgvdqlcvgedajftufkochbqjrqrvpzeplypoxgizhiifhdfknwdtqhetu\n2\naewerytrcreartaabtettruuevaaqr\nqwaeuberbvcavuvyucatvtuubcawye\nyaqerhzytzxeuuyjufqdfwmyiopagvfmjfinzzcnsdjfpgzdcijmacfxtqsvxkkonfferpcljphwxxhgxxvhkvgfsowumprkmssklsacbudrviljhklqdltuhjuxyyefkftcgoqafwnjasfbcdnrskcnbfnuhvruqvsiuxrlhlngyprpolkwyhjlfkbatznuukiepalwpupfxlkkbrsjj\n6\nqwewawrtcctvvwqccwvbqywuwbqbwq\naruayeevuctwwttatqabqrcbywtwvy\ntuwbqqewqevaqabbauwwtycayacawa\nwevvqtewqcwecwaqaccvaruutwetac\nabacvrwvwbqeqrvraetccewyuurewr\nwyeburacvyeretrcbrabucvqcubavy\nhfkrbocxnfvkhkjwptwdyhydqxpnvaacsrhjsmsskvhrqlqluuptzvsseucdqrjoqhvwgnjqhpcynyitbvxcpdcyovdihikdtsijveykcfzqofcmevtkbqhfssxalgoalzygpzlsvaeinjuitckspvivayqolwpbzvlphswmeywcpyhmexxqlqmarxzfwzndedhzmnsrymuvwhqfvfonouhshzizzzbiqcnkmrbwtgmgrhctpzwemdejftivtspguaxfpodhbxoscfbmepljrxmdsxjlgpnoybzdvliwatufubsaxuydkhugtcqikpfxhvctegdhgohhrpkbcstrambqjvtajdnfjtxekkfembpjwceiiotqpgzgmdazqhwgnfymqstqxxpxiklsdugtmrdaqonrlbalimmvwfepaofrfgusptpgjabundozjefyskchrjsixjgargslqfntbarxpeurtwgwtdbwbhfrwpbndoafqulepkuxcjljxylgmsogexxjmqgecoocqkzcfnmzttelieirtnojztaskrhypzhhikmk\n14\naawecquttcebyabwvvebttuewqreyw\nqbcttyuvecbcraberbvwtaraqwayqt\nyrrryyceeqrqawrwerbqtucvywcyqa\nrewtraavweccuwetvbaqwyttvayeba\nrtcvarqevevcywcqrbbqwurtaeecvb\naabucbrburerrccyrauwvvaewqeyct\nyytyrvyetyvqcvvcucqtqbqbcbeayy\nyururbwcveybuqyybecqqrbrvatevb\nvcttcvyqbqvqbecyywbavwqabayyea\nuacecuyebryqtcbeqrraweqawquwuw\necqvwvqtbutacettwyyqwwqwywwuye\nwqucetqurtuweewcryaqeerwvyrctv\naewbrbeueceyautvqtqtrqvcuwvarw\ncbywuruburcuwebqwyrtyuractrwey\nkhclxcumdhfmlryshmbrzhsgpzxsaisubwvhyqvmzjrdlacmsfsoehyeqmvwytackxsmqdfwshxalarplnlqfagvjgycpuqzhcvumxzkilwfvluvobeisjmmdrkwlotejovlbyipnrjheqtiqvrhklfcfjpbtkxqkkiasvwkkrpaikggeuhgvfaczdipcdeiefxrqoxrvbfvl\n2\nvbyrwcvqccratytrwarwrauyetvytw\nbwcyueqcawtewecyybqtvvabcycray\nrzmbrijtlaibzepsqchxfmptacpnopvcgkpayrwcgaofdqmmvttbwmcvfenytebzmvavjaidarqagstsxxzdldqlobbdmxywvvnwzbyyulddxttgritfaboacrkjanbiwgtptvmrupwyyqochrteqpamnihidugxkrnoowzwzhueuesvfgqqepfezvhjhharhbdbuziefcsfmusxalhrirvgghzsuioiihelklupawotlzdoekfltmlmdzfbdrwbskdpyszifyathxtfhzrcqpwuiwaapjwseyyhtxlpuausfcrzvvkojfftznugmizjlftpodmwowzxbjhbunsgecqboedemgdhvkrkargzxpudiryzryllftjatjmtwgsuvibgbkguvtffrznhoayhmlusemnnpfgecjivddgwirlabctzxwgigvplonauafgccazyfvvmtwlcrwdnfpphnikbcmyhtzejbrpvvjbpfefssavpqnbratflmxwgowpkhijldpzpobfwjpelgtzagbtxfdessawar",
"output": "NO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nNO",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n20\nqeevevbtaewcbtrqtyvbauyrauactw\nbutqrcbeebtayaqyuauvwwuaebavqe\nwuvtbbvqaqwuacqbvbwuyureeyayyt\ncavtwevvytcerrerurycqrwbrbebqv\nbcbvqwqatrvbyctbarqacbwtttqbcc\netcyrubybuwrtbuqubtcybbqwyuuwt\nweeqatybwyettcqarcwcvwyqwrwwwt\nectucwtratbwwacbwaqrawarywtuey\ntecyuywvrructbytttberqqavyqtet\nbtyracbyybvybuttreewceucwyuytv\nttwtqqybcywaqaqucrwvuyttwcqvyr\nuuuvvtewcuabtaecravuqurtqyqrev\nvyruebvrbuvuqaqytywrrtqcrytucr\nrrtaeayqrceqvyyaauwvuauurybcqe\nqebbvrqvcetqrtbbebubauwbrccwur\naqewwubweqwvrcuwerycuvbbaacqyb\nrrtwectcbaucayvtteawttwqcabaeb\nwyqrucecbrrwewubvcvrybaaucvtqb\navweubqtwqvqycaqauytvertqbcwyq\nex\netcyrubybuwrtbuqubtcybbqwyuuwtweeqatybwyettcqarcwcvwyqwrwwwtectucwtratbwwacbwaqrawarywtueye\n20\ntbqyrtawaueutatuwayquqqrycewvt\nrbqbauvybqbqucqwatycbuauqcvvcy\nrvcbvwyqqvyuqebteravewbaqquyye\nwrcbrarqbeauqarqccaybwteecueww\nytytuyebvtbcavqwyuwevcbtwytbrr\nabuequwrttwyvvtrqwwrvubyawrqqw\neqtvwayqtbytwqubueyrettayebuyy\nucarebwqteuacwybctwrcytyvyqvvw\nccttuwvqbayvtbacutqcvcyvqevqar\nvvewcbtctyuyctbwvaabtbraycquvr\ntqtqtawvuwyuteywqqvqvqvcvubcuw\nwtvycvbvrqbquqwveawrebqwbbuqev\nbvcbueeratwwcyvcvceuvrqacrbbcr\nwycteyavtuuqctuvttacreqwrvrrae\ntuqqqbytcyuqbewyquccqqvruecyaa\ntabywcyteartatqcaqebbyrrewycvu\nequyevvreuwcwcyeabtvyqwquvrwey\nvuycweatwrccuerwqquuabbctyuyvu\nqyabcawqqybueeqrbqwrvwetqvyqwu\nyx\nytytuyebvtbcavqwyuwevcbtwytbrrccttuwvqbayvtbacutqcvcyvqevqary\n20\nvwqbbyyracbryarcwveyavcyeybabb\nrwtratewarutertqywauvtqyaqvwcq\naeauwcrveutccvtbbawaecveueauur\nuryrtbeqwqwuerycqwvwuavaawqbaw\necwbqecyaqbbweryetyrrcbvqccqtb\neavaburayrctraarqtwvbcvevtyyqb\nqqyewuwtrecuycrwrqwyeuqqrqeqtt\nbareaqbbuqrvvvecrqqqcrcuqvretv\nrqvvbwbtberttyauauerebatybctyw\ntawwyywerqvvrcwbbbcvqteqvuuabw\nrcbqutbwttbevubtbacqacqucreqca\neqrwubqqqcvuyarcurtcbbtuytvrcq\nbvvbavvqaccryvbvawuwyewvwaqtwa\nvrqueccuvuaauvuqtbruebruqwveuq\nuaaywyvqcccvwyqeeavavcwwtvyvuw\nacctcuyacbctrwtcuyrurubrtqtbbc\nvevacarqevrctvaaqtyywrvqavabwv\nauevqbvuyeqercetqqcruccatcubtr\nbbqybvuvuverabbwarrvcyecacrebw\nvx\nvwqbbyyracbryarcwveyavcyeybabbaeauwcrveutccvtbbawaecveueauurbareaqbbuqrvvvecrqqqcrcuqvretvrqvvbwbtberttyauauerebatybctywv\n20\naacrtbqccyecuvecwyteurqvbcuvvc\nubyyceyvvttuacrecerwreyraectqw\neurvttqaatycyvyvwvqqqyuvvqarcc\nqevwceweabwqbuycqarecayaqyuvwt\nbvqyeuertcaeautcutuytaucvrcbyu\narqvayquwuuvwabctbqbewvbutwtcu\nqvrqwuuycewywywaatycuqrwtetyvq\nyawucaybevuaucbacbawytequetwqw\nuvbrquewcubertcwawwarrrteutquc\nuytyurutauabbyruuyuuaqbtyrwrbv\ncyquqccqquaryawayyyqabbatuvaet\ntuueyuuvwrrryrcvbrtrrtvqctycey\nutvqyacueerqutcvuvwtcqauuuqyeb\naabrtwrayrtbceuuvwqaactvrebwyy\nuyrcyyqrcbqybwrvewwyecuwrrttce\nytrtatwuuyauqecewccvbeaqavueeu\naaavcvurewweuyucubytabttabcvyc\nuyteuevbbqqbruvabrcrbeebuvcbtr\ntrwywuqwyqytbabyyryueabbbcrtcu\nax\naacrtbqccyecuvecwyteurqvbcuvvcqevwceweabwqbuycqarecayaqyuvwtarqvayquwuuvwabctbqbewvbutwtcuqvrqwuuycewywywaatycuqrwtetyvquvbrquewcubertcwawwarrrteutquca\n20\ncabetquwuatqbcqqectryvbtcywbec\ntayearbatctaauacuteyuawqbtvraa\nybcyuwvtatvtbbauwvbcrvycyteyab\nayqvwayyurcaywqbtavtwuvarruuwe\nawreyuearuvwwrytetacuvwcqcacca\nequvwveyrtqacryubvcuqwtwetwyvq\ntabwrrauqtwbcrrayraqyeuyycrbya\nwuuvqyebuavuvyybvaurauaqyerabu\nyarevayutrvyyqbecetrwrecybwruq\naqacuyeuqwuccecvbbveuwaaetrvbw\nryrwcrvvqaqwcvbwcbvutttratebeu\nrcweawabwyurqrvawwtebcutrywvqy\nurrwerrryvcywyyyrtcuuawvwauvre\nuutetcveqbccywqwtaeacqacwrutyq\ncacbbyyquuyeubeeeccwewcvvbvrru\naceurcvyetreyrwwwauytyvyuctwvc\nvqtqeuyvucrwubwtwqrraueevvycty\nvtqbbbcttuuavuawvbyuweyvvecvtq\nvvqqqurcvvaaycwetvqqaewuabevwt\nvyrvuttwbrcebucuraucerbwqweuav\nijqrvjzqcxdwsdyyfgbdbogyoowhahfdmwebvnfwqqppvgyaiownlozukseqpyusupafhutsyklbkdagjukleyqmfqcfgsrtjrmdqytivmnetfkstykageymvwywthnilkbpnqkodmmuaoqogzfribttcqdsdeolcrtykzidikjgvmdnvdyevvapeuxeugjakbnewvcqrqssekennysduhlhpydijxsmtppvirzafnkgeuenrkwyajmnosuodwnyeybwucwaefxvovkspnsgdnhsjfxaidyynkfyyvzxyeutuakdgeqitvrdwbewtajsxvzjlowsdrwznovrpyryozwgewxmpathwycxawxuyzxwjboybjjtghmhwfxcyjwhzboupqistbhxxwicxrpsezeypotnhcihvtkyrumeoy\n20\nqqaqcrervrvcrtaacwcvayyucuwavr\ntqvyvaqaeeuywbvequarwuvtveweav\nrcywrtebrwqucvucurwraaruutqecv\nbtrttwyuyqqutquccervwbvceybquu\neurewwctebquyucatcbcurrbaewcab\nwewqyeetbyqwyyyeaywtuartbvvqee\nwrvqcayaqeryerwywtaqttywarvbwe\nqevyuytbquwcqctucycvbtqvceyaur\naucbetywcuyruayvwwraebeyuecuev\ncvwcccrcyvubbebwqrwauycuqarwtq\nqyabrcbywqruyaraywvvrrutbvqcqv\naeuqyewuaweeucutuyuteabyubvbrq\nutrccacqwqvbreareeqrqcwtcywqyw\nvqcwvuqrcwrequcyeuyybbteareebe\nqeraubybbereteyqeyttqryetrwbyt\nvtqrwvycueqatwurqyarubaycebbet\ntavracvbrcytetqqbweatrvwbtybyu\naubyvaraaeqtbtwbtqtycrrbtrrvuc\nawwteucqvrtvcabutyaqucetwbbctw\neaccrtyuabuqcrcqwawctubquqyvqe\nwewqyeetbyqwyyyeaywtuartbvvqeeqevyuytbquwcqctucycvbtqvceyaur\n20\ntuvcetatcytqbbbaqwvcabvuvqwcec\nbrqcayvvrebqtuqwucrbctuebuuyrq\naqvqvyaaerywaawwtwrrqctwqybarw\neawuybtayvuccvwevtqrwtqvbybyeb\nwutacqutebcrrbuvcquryecvecbtrq\ncbauvcwrewaucuqacwwectwqbwyacc\nwqwurvuqvbttuyayarcraqwtuaywbe\nattarauuvqucrtqyvybaquubbuayuq\nyyeuravtwtrwqtawwayuwawryeywcy\ncuutaqbrtqwrwqvwqtbbwrteaywyeb\nrtavwvqywruayewvtqcacvvtayvaaw\nrwttbucccvewvattbtvvucuvrwyuye\ncarqqcuawayabycqwtrqauubetqree\ntuyvbraywvuquyreewccrtwvwerbwq\nycrqrvyqrrybvbvtutuuwcrecbtqer\nwraqcequybubwtwccetqvrqrbcurcr\nvyaaerrycuuvtwycbwubautwtwrcre\neebrceawatvyrwwcvrcceccbbaatrc\nvqvewewvacbuyabvbtubyaurqqqewb\ncqqebuutwrecqrbbervavrwecyewwe\nynqvrodakglryatfomqrjixuyjoplgmugugkliyphggewjdxqakjmoohatstyixjxzcuuwmikeyaqbxnzegemdfbeqskvjkjnrztpuscugbzqhjwohaaqobdyfpoilcb\n20\nerrucqwwawbqrwttccvvcwrtbcrwra\nucrqbtubqcctqateawvttyabeyyyyv\nuyvbtwqvqercvbruytucbqrrbbacey\ntttayyubqytcuycubturtuwvuurbrr\nceuyqwbwaeutbeucayuecwbtwreytv\nwutvwcwyubywbtbbrcvbuqcrbbbwwy\nebtwqcarbuveuctcyqqcubqwewabbt\nvvaqurvrceucbtacvvvbveewatecqb\ncacreewvcctvyeqryaqarvqaubvurc\ntyceyveqwyybtwytevwvbburrcqrvu\nuytwuqaatwavbtewuytrbtctwwqbtv\nwuvtcerccwyyueyeeeraryvrreqbua\nvutvbvqrtwtrccawbvvtcqqrvyuycq\nbawrbcwercveruvtyqutyuaarawbvy\nyeyrvuaryqyqaeuqtewyuccyevbayy\nvbcewywbqawbqebctaarqccqrqbcyq\nycyartrrurutayrvrycryycuqtycbc\nwwtcrecevecvubuwrqcaeutevwbubc\ncaqaqbbcwceyyavyawcryvateevcwy\neutrqbrevcabybuyqrvauttwtuberc\ndhasovxenrlmjhluqwcildbxwygldlnsfxeiwkixulvitewxfzpzfioaoqbyqwwjyqyshxxrcaw\n20\neacaawbtqcyuwytawwycawtabcaqyb\navuruvtvbcuvuwuqquayrvqbtbartr\nvrwcwrvrbvryyebwvcaebyqrvvrtue\nwcyruwwbwrrceuvtrrtebwecvbbwuw\nbrucybqrtquacruetcauevuaeqcqva\nabtrrbabwrwvqwbberqcycewevwqqa\nruuqqccaeyuytywtcterytyyvctvyq\nabuvrvbeyctarcvvtwarvwbcuewyar\nuvaerwbqveqtrtverqwvwuvcvwaeya\nrrtayqwrawaabbrrvrqcubrwbqtyet\nauqytybetetyqrrbyuqcvbbbqwbceq\nuraycutruvaqyweabyruewwqbrtybb\nbbqtcvbbeeuwqwverbcayrvurwecur\nwcvuqtqbruqvuaqtutbaewvryewrre\nbvyyyatubueaetyuvvcauatcvccvur\ntqbueurqcbcaqrbvayctaburrcywwt\nwrwbwyuavuvaucbvruqcyauceuvcbv\ncayevctccqreeqbubeevcrbqcwvrba\ncybbauttyrcayaaqbcwetyeqrbrtar\ntaaqevvqvubcuqtubbceuttwcbetua\njxvktnwzynvzidofjlfemguhjdkeawakeraalbtwxwvwmycqjzwonzxzvhoijxjcnmyrpaibgkfdvhauupnaqpoatvxhennmkwziwzbwsxkonqbuexuzyodqqpqgakpkdvsxicobpjqjzuknrscoumknqddpfxncnflolqdnwmpnvaaenfztiukxhxkargjjfhbanchfloieqygqtbjlpxvahwhsjssgiwaslhzaygmajoadfzeaptcprqizutdqywzsgqzdhooqsovfvzcliqqvofyhowfjfqkmbmuoxalvrjoawsyxonwgkouafocgeypsdqwjtumoxsgxsiltrappsxcunevehdkvowipqkunybgdwmoobakjxpadyohkptqbbcgbkiopxnprskenprlkisbijkhyvatnqzpgaqztwhhketjxtmsiikrpumkbhvznvvbtyluzlyeqccvwfgqrtdgkiznjfrucrpyvrqfjaptxwpoyzuwvvgjxrxwnvljjaedatmvhszgzqsjlloenmckdubywoudhvhohrdrhagyqevoevpqnsmzookmhdlqkxsfizwvsfgumpukbdimlisxauiaafpvdhqaf\n20\nuwvwuybbwbwyvqeyccbcwewbvttrqy\nutyuuauyttrwabcwtarwbwybbutrvu\nwabyqtaravwtayayuacbuvqwuqccet\nqtatbcyceuuawvyutrayyrbebvcyeq\naqratqccybywaetvbcbywawbwrrayb\ntqweewactrbbcbaqtawtucbbebtyrq\nwecqavbwqyaccvqbtartweqaecqtcu\nvqcuaycyawbtvbwveeecbybrcbecat\nyvqweyuuywtwvrqtueeyeerrqqyabc\nwqauaaayrebyybrqbvbeccccuyutyb\nwyqbwrcwvqquwwarequtcqvravuyce\nravvcveuvuwytqevbatyetaeabuuer\nvvqyyrttqaqvaqytbeebvuvrtuqawu\nvtqaqyqqbeywyarbcvbqvrcycyuryy\ncvwterrvaruywayqyebttwbacuwvtc\nyqyybubcbwbybatruaquyvvteuvrbc\nauawcabcqwrqeabycevcbcreecwbty\nvebutwwuvaavbyaqvvcbutbvutyewv\nyuaqwbuqeuubquebyrwrayartvcvrt\nvrvruvtrqqrecqucutccwuebcyqyqc\nuwvwuybbwbwyvqeyccbcwewbvttrqytqweewactrbbcbaqtawtucbbebtyrqwqauaaayrebyybrqbvbeccccuyutybvvqyyrttqaqvaqytbeebvuvrtuqawuvrvruvtrqqrecqucutccwuebcyqyqc",
"output": "NO\nNO\nNO\nNO\nNO\nYES\nNO\nNO\nNO\nYES",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | p00231 Dangerous Bridge | Solve the following coding problem using the programming language python:
In Aizuwakamatsu Village, which is located far north of Aizuwakamatsu City, a bridge called "Yabashi" is the only way to move to the surrounding villages. Despite the large number of passers-by, the bridge is so old that it is almost broken.
<image>
Yabashi is strong enough to withstand up to 150 [kg]. For example, 80 [kg] people and 50 [kg] people can cross at the same time, but if 90 [kg] people start crossing while 80 [kg] people are crossing, Yabashi will It will break.
If the Ya Bridge is broken, the people of Aizu Komatsu Village will lose the means to move to the surrounding villages. So, as the only programmer in the village, you decided to write a program to determine if the bridge would break based on how you crossed the bridge, in order to protect the lives of the villagers.
Number of passersby crossing the bridge n (1 β€ n β€ 100), weight of each passer mi (1 β€ mi β€ 100), time to start crossing the bridge ai, time to finish crossing bi (0 β€ ai, bi <231) If the bridge does not break, output "OK", and if it breaks, output "NG". If the total weight of passers-by on the bridge exceeds 150 [kg], the bridge will be destroyed. Also, at the time of ai, the passersby are on the bridge, but at the time of bi, they are not on the bridge.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
m1 a1 b1
m2 a2 b2
::
mn an ββbn
The number of datasets does not exceed 1200.
Output
For each input dataset, prints on one line whether the bridge will break or not.
Example
Input
3
80 0 30
50 5 25
90 27 50
3
80 0 30
70 5 25
71 30 50
0
Output
NG
OK
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
# coding: utf-8
# Your code here!
class Sch:
def __init__(self, m, t):
self.m = m
self.t = t
def __lt__(self,other):
if self.t == other.t:
return self.m < other.m
else:
return self.t < other.t
while True:
N = int(input())
if N == 0:
break
schedule = []
for l in range(N):
m,a,b = [int(i) for i in input().split()]
schedule.append(Sch(m,a))
schedule.append(Sch(-m,b))
schedule.sort()
M = 0
ans = "OK"
for i in range(len(schedule)):
M = M + schedule[i].m
if M > 150:
ans = "NG"
break
print(ans)
``` | vfc_34141 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 134217728,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n80 0 30\n50 5 25\n90 27 50\n3\n80 0 30\n70 5 25\n71 30 50\n0",
"output": "NG\nOK",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n80 0 30\n50 5 25\n90 27 50\n3\n80 0 30\n70 5 25\n71 30 84\n0",
"output": "NG\nOK\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n80 0 15\n64 5 25\n149 27 50\n3\n80 0 10\n70 10 25\n22 30 84\n0",
"output": "OK\nOK\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n80 0 30\n50 5 25\n90 27 50\n3\n80 0 30\n70 5 25\n71 23 50\n0",
"output": "NG\nNG\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n1 0 30\n50 5 25\n90 28 50\n3\n80 0 40\n70 5 25\n71 30 84\n0",
"output": "OK\nNG\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | p00609 Amazing Graze | Solve the following coding problem using the programming language python:
In 2215 A.D., a war between two planets, ACM and ICPC, is being more and more intense.
ACM introduced new combat planes. These planes have a special system that is called Graze, and fighting power of a plane increases when it is close to energy bullets that ICPC combat planes shoot.
Both combat planes and energy bullets have a shape of a sphere with a radius of R. Precisely, fighting power of a plane is equivalent to the number of energy bullet where distance from the plane is less than or equals to 2R.
You, helper of captain of intelligence units, are asked to analyze a war situation. The information given to you is coordinates of AN combat planes and BN energy bullets. Additionally, you know following things:
* All combat planes and energy bullet has same z-coordinates. In other word, z-coordinate can be ignored.
* No two combat planes, no two energy bullets, and no pair of combat plane and energy bullet collide (i.e. have positive common volume) each other.
Your task is to write a program that outputs total fighting power of all combat planes.
Constraints
* Jude data includes at most 20 data sets.
* 1 β€ AN, BN β€ 100000
* 0 < R β€ 10
* 0 β€ (coordinate values) < 10000
Input
Input file consists of a number of data sets. One data set is given in following format:
AN BN R
XA1 YA1
XA2 YA2
:
XAAN YAAN
XB1 YB1
XB2 YB2
:
XBBN YBBN
AN, BN, R are integers that describe the number of combat planes, energy bullets, and their radius respectively.
Following AN lines indicate coordinates of the center of combat planes. Each line has two integers that describe x-coordinate and y-coordinate.
Following BN lines indicate coordinates of the center of energy bullets, in the same format as that of combat planes.
Input ends when AN = BN = 0. You should output nothing for this case.
Output
For each data set, output the total fighting power.
Example
Input
2 2 1
0 0
0 4
2 2
2 8
0 0 0
Output
2
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_34149 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 134217728,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2 2 1\n0 0\n0 4\n2 2\n2 8\n0 0 0",
"output": "2",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 2 1\n0 0\n0 5\n2 2\n2 8\n0 0 0",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 2 1\n0 0\n0 4\n2 2\n2 12\n0 0 0",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 2 1\n0 0\n0 5\n2 4\n2 9\n0 0 0",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 2 1\n0 0\n0 4\n2 2\n2 2\n0 0 0",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 2 1\n1 0\n0 2\n1 10\n0 8\n0 0 0",
"output": "0\n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | p00746 Pablo Squarson's Headache | Solve the following coding problem using the programming language python:
Pablo Squarson is a well-known cubism artist. This year's theme for Pablo Squarson is "Squares". Today we are visiting his studio to see how his masterpieces are given birth.
At the center of his studio, there is a huuuuuge table and beside it are many, many squares of the same size. Pablo Squarson puts one of the squares on the table. Then he places some other squares on the table in sequence. It seems his methodical nature forces him to place each square side by side to the one that he already placed on, with machine-like precision.
Oh! The first piece of artwork is done. Pablo Squarson seems satisfied with it. Look at his happy face.
Oh, what's wrong with Pablo? He is tearing his hair! Oh, I see. He wants to find a box that fits the new piece of work but he has trouble figuring out its size. Let's help him!
Your mission is to write a program that takes instructions that record how Pablo made a piece of his artwork and computes its width and height. It is known that the size of each square is 1. You may assume that Pablo does not put a square on another.
I hear someone murmured "A smaller box will do". No, poor Pablo, shaking his head, is grumbling "My square style does not seem to be understood by illiterates".
<image>
Input
The input consists of a number of datasets. Each dataset represents the way Pablo made a piece of his artwork. The format of a dataset is as follows.
> N
n1 d1
n2 d2
...
nN-1 dN-1
The first line contains the number of squares (= N) used to make the piece of artwork. The number is a positive integer and is smaller than 200.
The remaining (N-1) lines in the dataset are square placement instructions. The line "ni di" indicates placement of the square numbered i (β€ N-1). The rules of numbering squares are as follows. The first square is numbered "zero". Subsequently placed squares are numbered 1, 2, ..., (N-1). Note that the input does not give any placement instruction to the first square, which is numbered zero.
A square placement instruction for the square numbered i, namely "ni di", directs it to be placed next to the one that is numbered ni, towards the direction given by di, which denotes leftward (= 0), downward (= 1), rightward (= 2), and upward (= 3).
For example, pieces of artwork corresponding to the four datasets shown in Sample Input are depicted below. Squares are labeled by their numbers.
<image>
The end of the input is indicated by a line that contains a single zero.
Output
For each dataset, output a line that contains the width and the height of the piece of artwork as decimal numbers, separated by a space. Each line should not contain any other characters.
Sample Input
1
5
0 0
0 1
0 2
0 3
12
0 0
1 0
2 0
3 1
4 1
5 1
6 2
7 2
8 2
9 3
10 3
10
0 2
1 2
2 2
3 2
2 1
5 1
6 1
7 1
8 1
0
Output for the Sample Input
1 1
3 3
4 4
5 6
Example
Input
1
5
0 0
0 1
0 2
0 3
12
0 0
1 0
2 0
3 1
4 1
5 1
6 2
7 2
8 2
9 3
10 3
10
0 2
1 2
2 2
3 2
2 1
5 1
6 1
7 1
8 1
0
Output
1 1
3 3
4 4
5 6
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
while True:
N = int(input())
w=[0]*N
h=[0]*N
wx=[-1,0,1,0]
hy=[0,-1,0,1]
if N == 0:
break
for i in range(1,N):
n,d = map(int,input().split())
w[i] = w[n]+wx[d]
h[i] = h[n]+hy[d]
print(max(w)-min(w)+1,max(h)-min(h)+1)
``` | vfc_34153 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 134217728,
"problem_url": null,
"time_limit": "{'seconds': 8, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "1\n5\n0 0\n0 1\n0 2\n0 3\n12\n0 0\n1 0\n2 0\n3 1\n4 1\n5 1\n6 2\n7 2\n8 2\n9 3\n10 3\n10\n0 2\n1 2\n2 2\n3 2\n2 1\n5 1\n6 1\n7 1\n8 1\n0",
"output": "1 1\n3 3\n4 4\n5 6",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n5\n0 0\n0 1\n0 2\n0 3\n12\n0 0\n1 1\n2 0\n3 1\n4 1\n5 1\n6 2\n7 2\n8 2\n9 3\n10 3\n10\n0 2\n1 2\n2 2\n3 2\n2 1\n5 1\n6 1\n7 1\n8 1\n0",
"output": "1 1\n3 3\n4 5\n5 6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n5\n0 0\n0 1\n0 2\n0 3\n12\n0 0\n1 0\n2 0\n3 1\n4 1\n5 1\n6 2\n7 2\n8 2\n9 3\n10 3\n10\n0 2\n1 3\n2 2\n3 2\n2 1\n5 1\n6 1\n7 1\n8 1\n0",
"output": "1 1\n3 3\n4 4\n4 6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n5\n0 0\n0 0\n0 2\n0 3\n12\n0 0\n1 0\n2 0\n3 1\n4 1\n5 1\n6 2\n7 2\n8 2\n9 3\n10 3\n10\n0 2\n1 3\n2 2\n3 2\n2 1\n5 1\n6 1\n7 1\n8 1\n0",
"output": "1 1\n3 2\n4 4\n4 6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n5\n0 0\n0 0\n0 2\n0 3\n12\n0 0\n1 0\n2 0\n3 0\n4 1\n5 1\n6 2\n7 2\n8 2\n9 3\n10 3\n10\n0 2\n1 3\n2 2\n3 2\n2 1\n5 1\n6 1\n7 1\n8 1\n0",
"output": "1 1\n3 2\n5 3\n4 6\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | p00885 Balloon Collecting | Solve the following coding problem using the programming language python:
"Balloons should be captured efficiently", the game designer says. He is designing an oldfashioned game with two dimensional graphics. In the game, balloons fall onto the ground one after another, and the player manipulates a robot vehicle on the ground to capture the balloons. The player can control the vehicle to move left or right, or simply stay. When one of the balloons reaches the ground, the vehicle and the balloon must reside at the same position, otherwise the balloon will burst and the game ends.
<image>
Figure B.1: Robot vehicle and falling balloons
The goal of the game is to store all the balloons into the house at the left end on the game field. The vehicle can carry at most three balloons at a time, but its speed changes according to the number of the carrying balloons. When the vehicle carries k balloons (k = 0, 1, 2, 3), it takes k+1 units of time to move one unit distance. The player will get higher score when the total moving distance of the vehicle is shorter.
Your mission is to help the game designer check game data consisting of a set of balloons. Given a landing position (as the distance from the house) and a landing time of each balloon, you must judge whether a player can capture all the balloons, and answer the minimum moving distance needed to capture and store all the balloons. The vehicle starts from the house. If the player cannot capture all the balloons, you must identify the first balloon that the player cannot capture.
Input
The input is a sequence of datasets. Each dataset is formatted as follows.
n
p1 t1
.
.
.
pn tn
The first line contains an integer n, which represents the number of balloons (0 < n β€ 40). Each of the following n lines contains two integers pi and ti (1 β€ i β€ n) separated by a space. pi and ti represent the position and the time when the i-th balloon reaches the ground (0 < pi β€ 100, 0 < ti β€ 50000). You can assume ti < tj for i < j. The position of the house is 0, and the game starts from the time 0.
The sizes of the vehicle, the house, and the balloons are small enough, and should be ignored. The vehicle needs 0 time for catching the balloons or storing them into the house. The vehicle can start moving immediately after these operations.
The end of the input is indicated by a line containing a zero.
Output
For each dataset, output one word and one integer in a line separated by a space. No extra characters should occur in the output.
* If the player can capture all the balloons, output "OK" and an integer that represents the minimum moving distance of the vehicle to capture and store all the balloons.
* If it is impossible for the player to capture all the balloons, output "NG" and an integer k such that the k-th balloon in the dataset is the first balloon that the player cannot capture.
Example
Input
2
10 100
100 270
2
10 100
100 280
3
100 150
10 360
40 450
3
100 150
10 360
40 440
2
100 10
50 200
2
100 100
50 110
1
15 10
4
1 10
2 20
3 100
90 200
0
Output
OK 220
OK 200
OK 260
OK 280
NG 1
NG 2
NG 1
OK 188
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-1,1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
while True:
n = I()
if n == 0:
break
a = [LI() for _ in range(n)]
d = collections.defaultdict(lambda: inf)
d[0] = 0
cp = 0
ct = 0
r = inf
for i in range(n):
p,t = a[i]
e = collections.defaultdict(lambda: inf)
for k,ck in list(d.items()):
if k < 3 and abs(cp-p) * (k+1) + ct <= t:
if e[k+1] > ck + abs(cp-p):
e[k+1] = ck + abs(cp-p)
if cp * (k+1) + p + ct <= t:
if e[1] > ck + cp + p:
e[1] = ck + cp + p
d = e
if len(e) == 0:
r = i + 1
break
cp = p
ct = t
if r < inf:
rr.append('NG {}'.format(r))
else:
for k,ck in d.items():
if r > ck + cp:
r = ck + cp
rr.append('OK {}'.format(r))
return '\n'.join(map(str,rr))
print(main())
``` | vfc_34157 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 134217728,
"problem_url": null,
"time_limit": "{'seconds': 8, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n10 100\n100 270\n2\n10 100\n100 280\n3\n100 150\n10 360\n40 450\n3\n100 150\n10 360\n40 440\n2\n100 10\n50 200\n2\n100 100\n50 110\n1\n15 10\n4\n1 10\n2 20\n3 100\n90 200\n0",
"output": "OK 220\nOK 200\nOK 260\nOK 280\nNG 1\nNG 2\nNG 1\nOK 188",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | p01016 Password | Solve the following coding problem using the programming language python:
Taro had his own personal computer and set a password for login. However, Taro inadvertently forgot the password. Then, remembering that there was a piece of paper with the password written down, Taro found the paper and was surprised to see it. The paper was cut and there were only fragments, and there were some stains that made it unreadable. Taro decided to guess the password by referring to the memo.
Constraints
* The length of the character strings A and B is 1 to 1000 characters.
* The length of the B string does not exceed the length of the A string.
Input
String A
String B
Output
Output "Yes" or "No" on one line.
Examples
Input
ABCDE
ABC
Output
Yes
Input
KUSATSU
KSATSU
Output
No
Input
ABCABC
ACBA_B
Output
No
Input
RUPCUAPC
__PC
Output
Yes
Input
AIZU
_A
Output
No
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
a = input()
b = input()
length_a = len(a)
length_b = len(b)
def check():
for i in range(length_a - length_b + 1):
for j in range(length_b):
if b[j] == "_" or a[i + j] == b[j]:continue
else:break
else:
print("Yes")
return
print("No")
return
check()
``` | vfc_34161 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 268435456,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "KUSATSU\nKSATSU",
"output": "No",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "ABCABC\nACBA_B",
"output": "No",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "RUPCUAPC\n__PC",
"output": "Yes",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "AIZU\n_A",
"output": "No",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "ABCDE\nABC",
"output": "Yes",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "KUSATSU\nLSATSU",
"output": "No\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | p01149 Blackjack | Solve the following coding problem using the programming language python:
Brian Jones is an undergraduate student at Advanced College of Metropolitan. Recently he was given an assignment in his class of Computer Science to write a program that plays a dealer of blackjack.
Blackjack is a game played with one or more decks of playing cards. The objective of each player is to have the score of the hand close to 21 without going over 21. The score is the total points of the cards in the hand. Cards from 2 to 10 are worth their face value. Face cards (jack, queen and king) are worth 10 points. An ace counts as 11 or 1 such a way the score gets closer to but does not exceed 21. A hand of more than 21 points is called bust, which makes a player automatically lose. A hand of 21 points with exactly two cards, that is, a pair of an ace and a ten-point card (a face card or a ten) is called a blackjack and treated as a special hand.
The game is played as follows. The dealer first deals two cards each to all players and the dealer himself. In case the dealer gets a blackjack, the dealer wins and the game ends immediately. In other cases, players that have blackjacks win automatically. The remaining players make their turns one by one. Each player decides to take another card (hit) or to stop taking (stand) in his turn. He may repeatedly hit until he chooses to stand or he busts, in which case his turn is over and the next player begins his play. After all players finish their plays, the dealer plays according to the following rules:
* Hits if the score of the hand is 16 or less.
* Also hits if the score of the hand is 17 and one of aces is counted as 11.
* Stands otherwise.
Players that have unbusted hands of higher points than that of the dealer win. All players that do not bust win in case the dealer busts. It does not matter, however, whether players win or lose, since the subject of the assignment is just to simulate a dealer.
By the way, Brian is not good at programming, thus the assignment is a very hard task for him.
So he calls you for help, as you are a good programmer. Your task is to write a program that counts the score of the dealerβs hand after his play for each given sequence of cards.
Input
The first line of the input contains a single positive integer N , which represents the number of test cases. Then N test cases follow.
Each case consists of two lines. The first line contains two characters, which indicate the cards in the dealerβs initial hand. The second line contains eight characters, which indicate the top eight cards in the pile after all players finish their plays.
A character that represents a card is one of A, 2, 3, 4, 5, 6, 7, 8, 9, T, J, Q and K, where A is an ace, T a ten, J a jack, Q a queen and K a king.
Characters in a line are delimited by a single space.
The same cards may appear up to four times in one test case. Note that, under this condition, the dealer never needs to hit more than eight times as long as he or she plays according to the rule described above.
Output
For each case, print on a line βblackjackβ if the dealer has a blackjack; βbustβ if the dealer busts; the score of the dealerβs hand otherwise.
Example
Input
4
5 4
9 2 8 3 7 4 6 5
A J
K Q J T 9 8 7 6
T 4
7 J A 6 Q T K 7
2 2
2 3 4 K 2 3 4 K
Output
18
blackjack
21
bust
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
N=int(raw_input())
for i in range(N):
hand=raw_input().split()
deck=raw_input().split()
#defaulthand
d=0
points=0
for i in range(len(hand)):
if hand[i] in ['T','J','Q','K']:
hand[i]=10
elif hand[i]=='A':
hand[i]=11
else:
hand[i]=int(hand[i])
for i in range(len(deck)):
if deck[i] in ['T','J','Q','K']:
deck[i]=10
elif deck[i]=='A':
deck[i]=11
else:
deck[i]=int(deck[i])
points=sum(hand)
if points==21:
print 'blackjack'
else:
while(1):
if points>21 and 11 in hand:
hand.remove(11)
hand.append(1)
points=points-10
if (points<17) or (points<18 and 11 in hand):
hand.append(deck[d])
points=points+deck[d]
d=d+1
else:
break
if points>21:
print 'bust'
else:
print points
``` | vfc_34165 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 134217728,
"problem_url": null,
"time_limit": "{'seconds': 8, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n5 4\n9 2 8 3 7 4 6 5\nA J\nK Q J T 9 8 7 6\nT 4\n7 J A 6 Q T K 7\n2 2\n2 3 4 K 2 3 4 K",
"output": "18\nblackjack\n21\nbust",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n5 4\n9 2 8 3 9 4 6 5\nA J\nK Q J T 9 8 7 6\nT 4\n7 J A 6 Q T K 7\n2 2\n2 3 4 K 2 3 4 K",
"output": "18\nblackjack\n21\nbust\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | p01288 Marked Ancestor | Solve the following coding problem using the programming language python:
You are given a tree T that consists of N nodes. Each node is numbered from 1 to N, and node 1 is always the root node of T. Consider the following two operations on T:
* M v: (Mark) Mark node v.
* Q v: (Query) Print the index of the nearest marked ancestor of node v which is nearest to it. Initially, only the root node is marked. Note that a node is an ancestor of itself.
Your job is to write a program that performs a sequence of these operations on a given tree and calculates the value that each Q operation will print. To avoid too large output file, your program is requested to print the sum of the outputs of all query operations. Note that the judges confirmed that it is possible to calculate every output of query operations in a given sequence.
Input
The input consists of multiple datasets. Each dataset has the following format:
The first line of the input contains two integers N and Q, which denotes the number of nodes in the tree T and the number of operations, respectively. These numbers meet the following conditions: 1 β€ N β€ 100000 and 1 β€ Q β€ 100000.
The following N - 1 lines describe the configuration of the tree T. Each line contains a single integer pi (i = 2, ... , N), which represents the index of the parent of i-th node.
The next Q lines contain operations in order. Each operation is formatted as "M v" or "Q v", where v is the index of a node.
The last dataset is followed by a line containing two zeros. This line is not a part of any dataset and should not be processed.
Output
For each dataset, print the sum of the outputs of all query operations in one line.
Example
Input
6 3
1
1
2
3
3
Q 5
M 3
Q 5
0 0
Output
4
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
def root(x):
while P[x] != x:
x = P[x]
return x
def mark(x):
P[x-1] = x-1
def query(x):
v = root(x-1) +1
return v
while True:
N,Q = map(int,input().strip().split(" "))
if N == Q == 0:
break
P = []
P.append(0)
for i in range(N-1):
p_i = int(input().strip()) -1
P.append(p_i)
s = 0
for j in range(Q):
op = input().strip().split(" ")
if op[0] == "M":
mark(int(op[1]))
else:
s += query(int(op[1]))
print(s)
``` | vfc_34169 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 134217728,
"problem_url": null,
"time_limit": "{'seconds': 8, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6 3\n1\n1\n2\n3\n3\nQ 5\nM 3\nQ 5\n0 0",
"output": "4",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6 3\n2\n1\n2\n3\n3\nQ 5\nM 3\nQ 5\n0 0",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6 3\n1\n1\n2\n3\n3\nQ 5\nM 4\nQ 5\n0 0",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6 3\n0\n1\n2\n3\n3\nQ 5\nM 5\nQ 5\n0 0",
"output": "6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6 3\n0\n1\n2\n3\n1\nQ 5\nM 4\nQ 4\n0 0",
"output": "5\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | p01457 Carpenters' Language | Solve the following coding problem using the programming language python:
International Carpenters Professionals Company (ICPC) is a top construction company with a lot of expert carpenters. What makes ICPC a top company is their original language.
The syntax of the language is simply given in CFG as follows:
S -> SS | (S) | )S( | Ξ΅
In other words, a right parenthesis can be closed by a left parenthesis and a left parenthesis can be closed by a right parenthesis in this language.
Alex, a grad student mastering linguistics, decided to study ICPC's language. As a first step of the study, he needs to judge whether a text is well-formed in the language or not. Then, he asked you, a great programmer, to write a program for the judgement.
Alex's request is as follows: You have an empty string S in the beginning, and construct longer string by inserting a sequence of '(' or ')' into the string. You will receive q queries, each of which consists of three elements (p, c, n), where p is the position to insert, n is the number of characters to insert and c is either '(' or ')', the character to insert. For each query, your program should insert c repeated by n times into the p-th position of S from the beginning. Also it should output, after performing each insert operation, "Yes" if S is in the language and "No" if S is not in the language.
Please help Alex to support his study, otherwise he will fail to graduate the college.
Input
The first line contains one integer q (1 \leq q \leq 10^5) indicating the number of queries, follows q lines of three elements, p_i, c_i, n_i, separated by a single space (1 \leq i \leq q, c_i = '(' or ')', 0 \leq p_i \leq length of S before i-th query, 1 \leq n \leq 2^{20}). It is guaranteed that all the queries in the input are valid.
Output
For each query, output "Yes" if S is in the language and "No" if S is not in the language.
Examples
Input
3
0 ( 10
10 ) 5
10 ) 5
Output
No
No
Yes
Input
3
0 ) 10
10 ( 5
10 ( 5
Output
No
No
Yes
Input
3
0 ( 10
10 ) 20
0 ( 10
Output
No
No
Yes
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
n = I()
ni = 0
t = 0
while ni < n:
ni += 1
a = LS()
if a[1] == '(':
t -= int(a[2])
else:
t += int(a[2])
if t == 0:
rr.append('Yes')
else:
rr.append('No')
return '\n'.join(map(str, rr))
print(main())
``` | vfc_34173 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 134217728,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n0 ( 10\n10 ) 20\n0 ( 10",
"output": "No\nNo\nYes",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n0 ( 10\n10 ) 5\n10 ) 5",
"output": "No\nNo\nYes",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n0 ) 10\n10 ( 5\n10 ( 5",
"output": "No\nNo\nYes",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n0 ( 10\n10 ) 5\n10 ( 5",
"output": "No\nNo\nNo\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n-1 ( 10\n10 ) 5\n10 ) 5",
"output": "No\nNo\nYes\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | p01608 1 | Solve the following coding problem using the programming language python:
1
Problem Statement
There is a bit string of length n.
When the i-th bit from the left is 1, the score is a_i points.
The number of 1s within the distance w around the i-th bit from the left (= | \\ {j \ in \\ {1, ..., n \\} β© \\ {iw, ..., i + w \\} | When the jth bit from the left is 1 \\} |) is odd, the score is b_i.
Find the bit string that gives the most scores.
Constraints
* 1 β€ n β€ 1,000
* 1 β€ w β€ 1,000
* 0 β€ a_i β€ 10 ^ 5
* 0 β€ b_i β€ 10 ^ 5
Input
Input follows the following format. All given numbers are integers.
n w
a_1 ... a_n
b_1 ... b_n
Output
Output the bit string that gives the most scores on one line.
If there are multiple such solutions, any of them may be output.
Examples
Input
4 1
3 1 2 7
13 8 25 9
Output
1001
Input
2 1
1 1
3 3
Output
10
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_34177 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 134217728,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 1\n3 1 2 7\n13 8 25 9",
"output": "1001",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | p01903 Overflow of Furo | Solve the following coding problem using the programming language python:
F: Bath overflows --Overflow of Furo -
story
The hot spring inn Paro is passionate about the hot springs that it is proud of, and is attracting professional bathers. Bath professionals mainly manage the plumbing of hot springs, and manage and coordinate the complicated and intricate plumbing network that connects multiple sources to one large communal bath.
The management and adjustment work of the piping network is also quite difficult, but the bath professionals sewn in between and made efforts every day to supply more hot water to the bathtub. As a result, bath professionals have mastered the trick of "only one pipe can be overflowed." In other words, it became possible to freely choose one pipe and remove the limitation on the amount of hot water in that pipe.
Bath professionals who have previously relied on your program to set up a plumbing network to achieve maximum hot water can reprogram to you how to use this technology to further increase the amount of hot water supplied to the bathtub. I asked you to write.
problem
There is a plumbing network with one bathtub, K sources and N junctions. The piping network consists of M pipes, and each pipe has a limit on the amount of hot water that can be flowed. Since the direction in which hot water flows is not determined for each pipe, you can freely decide and use it. At the N coupling points, the hot water flowing from some pipes can be freely distributed to some other pipes. All sources and bathtubs are at the end points of some pipes, and hot water is supplied from the source to the bathtub by adjusting the amount of hot water from the source and the amount of hot water at the joint point.
What is the maximum amount of hot water that can be supplied to the bathtub by overflowing only one of the M pipes, that is, increasing the amount of hot water that can be flowed infinitely? However, it is possible that the maximum amount of hot water supplied can be increased infinitely, but in that case the bath will overflow, so output "overfuro".
Input format
The input is given in the following format.
K N M
a_1 b_1 c_1
...
a_M b_M c_M
All inputs consist of integers. The first row gives the number of sources K, the number of coupling points N, and the number of pipes M. In the i-th line of the following M lines, three integers a_i, b_i, and c_i representing the information of the i-th pipe are given. This indicates that the points at both ends of the i-th pipe are a_i and b_i, respectively, and the limit on the amount of hot water is c_i. Here, when the end point x of the pipe is 0, it means that it is a large communal bath, when it is from 1 to K, it means that it is the xth source, and when it is from K + 1 to K + N, it means that it is the x β Kth connection point. ..
Constraint
* 1 β€ K
* 0 β€ N
* N + K β€ 100
* 1 β€ M β€ (N + K + 1) (N + K) / 2
* 0 β€ a_i, b_i β€ K + N
* a_i β b_i
* 1 β€ c_i β€ 5 {,} 000
* It is guaranteed that no more than one pipe has the same two endpoints.
* The given plumbing network is guaranteed to be able to supply at least one hot water from the source to the bathtub without overflowing the plumbing.
Output format
Output the maximum amount of hot water supplied from the source to the bathtub in one line when only one pipe overflows and the amount of hot water supplied from the source to the bathtub is maximized. However, if you can increase the maximum amount of hot water infinitely, output "overfuro" on one line.
Input example 1
2 2 4
1 3 4
2 4 2
0 3 3
4 0 5
Output example 1
8
Input example 2
2 3 7
1 0 8
2 0 9
3 0 3
0 4 5
5 0 2
1 3 2
2 4 9
Output example 2
overfuro
Input example 3
1 1 2
0 2 1
1 2 1
Output example 3
1
Input example 4
5 0 5
0 1 1
0 2 1
0 3 1
0 4 1
0 5 1
Output example 4
overfuro
Example
Input
2 2 4
1 3 4
2 4 2
0 3 3
4 0 5
Output
8
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_34185 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 268435456,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2 2 4\n1 3 4\n2 4 2\n0 3 3\n4 0 5",
"output": "8",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 3 4\n1 3 4\n2 4 2\n0 3 3\n4 0 5",
"output": "8\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 3 4\n1 3 4\n2 4 3\n0 3 3\n4 0 5",
"output": "overfuro\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 2 4\n1 3 4\n2 4 2\n0 3 2\n4 0 5",
"output": "7\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 3 7\n1 3 4\n2 4 1\n0 3 3\n5 0 5",
"output": "4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 2 4\n1 3 7\n0 4 4\n0 3 2\n4 1 5",
"output": "11\n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | p02041 LISum | Solve the following coding problem using the programming language python:
problem
Given the sequence $ A $ of length $ N $. Find the maximum value of $ \ sum B_i $, where $ B $ is one of the longest increasing subsequences of the sequence $ A $.
The longest increasing subsequence of the sequence $ A $ is the longest subsequence that satisfies $ A_i <A_j $ with all $ i <j $.
output
Output the maximum value of $ \ sum B_i $, where $ B $ is one of the longest increasing subsequences of the sequence $ A $. Also, output a line break at the end.
Example
Input
4
6 4 7 8
Output
21
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import bisect
N = int(input())
A = list(map(int,input().split()))
lis = []
hist = []
for a in A:
i = bisect.bisect_left(lis,a)
if i == len(lis):
lis.append(a)
hist.append([a])
else:
lis[i] = a
hist[i].append(a)
ans = last = hist[-1][0]
for row in reversed(hist[:-1]):
i = bisect.bisect_left(row[::-1], last)
last = row[-i]
ans += last
print(ans)
``` | vfc_34189 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 268435456,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n6 4 7 8",
"output": "21",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n7 4 7 8",
"output": "19\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n7 4 1 8",
"output": "15\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n7 4 2 9",
"output": "16\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | p02184 Canisar Cipher | Solve the following coding problem using the programming language python:
C: Canisal cryptography
problem
Ebi-chan was given the string C obtained by encrypting a non-negative integer D with "canisal cipher". This cipher replaces each number in decimal notation with a fixed number (not necessarily different from the original). Different numbers will not be replaced with the same number, and the same number will not be rewritten to a different number depending on the position of appearance.
For example, this encryption method can result in 2646 being 0545, but not 3456 being 1333 or 1333 being 3456.
Now, Ebi-chan has been told that the remainder of dividing D by 10 ^ 9 + 7 is M. At this time, output one that can be considered as D. If you can think of more than one, you can output any of them. However, it is assumed that there is no extra `0` at the beginning of D.
Input format
M
C
Constraint
* 0 \ leq M <10 ^ 9 + 7
* 1 \ leq | C | \ leq 10 ^ 5
Output format
Print a non-negative integer that can be considered as D on one line. If it does not exist, output `-1`.
Input example 1
2
1000000007
Output example 1
1000000009
The encryption method this time was to replace 0 with 0, 1 with 1, and 9 with 7.
Input example 2
3
1000000007
Output example 2
-1
Input example 3
1
01 01
Output example 3
-1
There is no extra `0` at the beginning of the D.
Input example 4
45
1000000023
Output example 4
6000000087
Since `1000000052` and` 2000000059` also satisfy the conditions, you can output them.
Input example 5
0
940578326285963740
Output example 5
123456789864197523
Example
Input
2
1000000007
Output
1000000009
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
# εεε
¨εζ
from itertools import permutations, combinations
M = int(input())
C = list(map(int, input()))
if len(C)==1 and M==0:
print(0)
exit()
mod = 10**9 + 7
L = [0] * 10
b = 1
for c in C[::-1]:
L[c] += b
b = b * 10 % mod
for t_half1 in combinations(range(10), 5):
L1, L2 = L[:5], L[5:]
t_half2 = list(set(range(10)) - set(t_half1))
if int(C[0]) < 5:
s1 = {sum(l * n for l, n in zip(L1, t1)) % mod: t1 for t1 in reversed(list(permutations(t_half1))) if t1[int(C[0])] != 0}
else:
s1 = {sum(l * n for l, n in zip(L1, t1)) % mod: t1 for t1 in reversed(list(permutations(t_half1)))}
for t2 in permutations(t_half2):
s = sum(l * n for l, n in zip(L2, t2))
if (M-s) % mod in s1:
t = s1[(M-s) % mod] + t2
if t[int(C[0])] != 0:
print("".join(map(lambda x: str(t[x]), C)))
exit()
print(-1)
``` | vfc_34193 | {
"difficulty": "0",
"memory_limit": null,
"memory_limit_bytes": 268435456,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n1000000007",
"output": "1000000009",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1036219253",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n8",
"output": "2",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n1612950356",
"output": "-1\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | aou | Solve the following coding problem using the programming language python:
For Turbo C++ Users : Read the following document before attempting the question :
Problem Description
Hank Pym is an aspiring student at IIITD. He has almost completed his work on Ultron, the ultimate artificial intelligence. However, one thing remains. He feels that Ultron should have a fail-safe code which can be used to switch him off (just in case Ultron decides to wipe out our race). So, he encodes the number and feeds it into Ultron. Hank shares the number with the rest of the Avengers and the way to decrypt it:
Divide the encrypted number βNβ by its biggest prime divisor. Now, divide the resultant number by its biggest prime divisor and continue the process (i.e., recursively) until the resultant number doesnβt have any prime divisors. The decrypted code is the number of times you have to do this process.
Hank wants you to decrypt the number for him, so that he may store it somewhere safe (maybe inside one of the books at the IIITD library).Can you help Hank?
Input
First line contains βTβ, the number of test cases.
Each test case is given on a new line, which consists of a number the encrypted number 'N'.
Output
For each test case, print the decrypted number.
Constraints
Should contain all the constraints on the input data that you may have. Format it like:
1 β€ T β€ 100
1 β€ N β€ 10^9
Example
Input:
4
2
9
100
17
Output:
1
2
4
1
Β
Explanation
For the first test case, 2 has no prime divisors apart from itself. So, the answer is 1.
For the second test case, 9 has 3 as the only prime divisor. Dividing it by 3, we get 3.Dividing 3 by itself, we get 1, which has no prime divisors. So, the answer is 2.
For the third test case, the largest prime divisor is 5. Dividing, we get 20.The largest prime factor of 20 is 5. So, dividing by 5, we get 4. The largest prime factor of 4 is 2. Dividing, we get 2. Again dividing 2 by 2, we stop at 1.So, we did the division 4 times. Hence, the answer is 4.
The fourth test case is similar to the first test case.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
max = 10**5
a = [True]*max
prime = []
for i in range(2,max):
if a[i]:
prime.append(i)
j = 2*i
while j < max:
a[j] = False
j += i
n = input()
for z in range(n):
k = input()
count = 0
track = 0
while track < len(prime) and k!=1:
while k%prime[track] == 0:
count += 1
k /= prime[track]
track += 1
if k != 1:
count += 1
print count
``` | vfc_34205 | {
"difficulty": "6",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n2\n9\n100\n17",
"output": "1\n2\n4\n1",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n2\n9\n100\n28",
"output": "1\n2\n4\n3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n2\n9\n101\n17",
"output": "1\n2\n1\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n2\n9\n001\n17",
"output": "1\n2\n0\n1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n2\n9\n100\n16",
"output": "1\n2\n4\n4\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n2\n13\n101\n17",
"output": "1\n1\n1\n1\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | cielab | Solve the following coding problem using the programming language python:
In Ciel's restaurant, a waiter is training.
Since the waiter isn't good at arithmetic, sometimes he gives guests wrong change.
Ciel gives him a simple problem.
What is A-B (A minus B) ?
Surprisingly, his answer is wrong.
To be more precise, his answer has exactly one wrong digit.
Can you imagine this?
Can you make the same mistake in this problem?
Input
An input contains 2 integers A and B.
Output
Print a wrong answer of A-B.
Your answer must be a positive integer containing the same number of digits as the correct answer, and exactly one digit must differ from the correct answer.
Leading zeros are not allowed.
If there are multiple answers satisfying the above conditions, anyone will do.
Constraints
1 β€ B < A β€ 10000
Sample Input
5858 1234
Sample Output
1624
Output details
The correct answer of 5858-1234 is 4624.
So, for instance, 2624, 4324, 4623, 4604 and 4629 will be accepted, but 0624, 624, 5858, 4624 and 04624 will be rejected.
Notes
The problem setter is also not good at arithmetic.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
test = map(int,raw_input().split())
count = str(abs(test[0] - test[1]))
l = ['1','2','3','4','5','6','7','8','9']
l.remove(count[0])
string = ''
string += l[0]
string += count[1:len(count)+1]
print int(string)
``` | vfc_34209 | {
"difficulty": "2",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5858 1234",
"output": "1624\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5858 2439",
"output": "1419\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5858 2389",
"output": "1469\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10125 2389",
"output": "1736\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "15844 2389",
"output": "23455\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "15844 3628",
"output": "22216\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | etmx06 | Solve the following coding problem using the programming language python:
Common Integer
Andy wants to prove his practical programming knowledge to his old pal.
He will get two numbers both in the range 10 to 99.
if there exists a comon integer in both the numbers, he has to write TRUE or else FALSE.
For Example: if input numbers are 12 and 24, the output must be TRUE since the common integer is 2 in both numbers.
Help Andy by developing a code that does his job.
Input
First line is two numbers separated by a space. The numbers must be in between 10 and 99.
Output
Next line is the output TRUE or FALSE depending on the input.
Example
Input:
12 24
Output:
TRUE
Input:
11 34
Output:
FALSE
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
x=raw_input()
a,b=x.split()
d=0
for i in a:
if i in b:
print "TRUE"
d=1
break
if d==0:
print "FALSE"
``` | vfc_34213 | {
"difficulty": "6",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "11 34",
"output": "FALSE",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "12 24",
"output": "TRUE",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "19 34",
"output": "FALSE\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "19 90",
"output": "TRUE\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 24",
"output": "FALSE\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | ladybug1 | Solve the following coding problem using the programming language python:
Mrs. Verma has decided to sell his car. N people have offered to buy the car. Instead of selling to the highest bidder, Mrs. Verma decides to sell his company to the Kth lowest bidder. How much money will Mrs. Verma get?
Input
The first line of the input contains 2 space-separated integers, N and K. The next line contains N space separated integers A1, A2, ..., AN, denoting the money each of the N people are willing to pay.
Output
Print a single integer, denoting the money Mrs/ Verma will sell his company for.
Constraints
1 β€ K β€ N β€ 1000
1 β€ Ai β€ 10000
Example
Input:
5 4
1 2 1 3 3
Output:
3
Explanation
Out of the 5 bids, the 4th lowest amount is 3.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
n, k = map(int, raw_input().split()); a = [int(i) for i in raw_input().split()];
a.sort(); print a[k - 1];
``` | vfc_34217 | {
"difficulty": "6",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5 4\n1 2 1 3 3",
"output": "3",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | pcsc2 | Solve the following coding problem using the programming language python:
Phillip has become fascinated with sequences lately. He looks for sequences all the time. His favorite sequence is the Fibonacci sequence, where any element is equal to the sum of the two previous elements. However, he isn't able to figure out the correct number for positions beyond 8 without writing it on paper. Create a program that will take in the first two number of a Fibonacci sequence and a number of places to calculate, and print out the number that is at that place.
Β
Input
The first two numbers of a Fibonacci sequence, and the to print out. Note: you only need to handle 1 sequence per run.
Output
The number at the position specified.
Example 1
Input:
1 1 5
Output:
5
Example 2
Input
1 5 7
Output
45
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
fib=[]
i1,i2,i3=map(int, raw_input().split())
y=i3
p=i1
fib.append(p)
r=i2
fib.append(r)
while(y):
n=p+r
fib.append(n)
p=r
r=n
y-=1
print fib.pop((i3-1))
``` | vfc_34221 | {
"difficulty": "6",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "1 5 7",
"output": "45",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | start01 | Solve the following coding problem using the programming language python:
Problem Statement
Write a program that accepts a number and outputs the same.
Sample Input
123
Sample Output
123
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
num=int(raw_input())
print num
``` | vfc_34225 | {
"difficulty": "1",
"memory_limit": null,
"memory_limit_bytes": 0,
"problem_url": null,
"time_limit": "None"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "123",
"output": "123\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1008_A. Romaji | Solve the following coding problem using the programming language python:
Vitya has just started learning Berlanese language. It is known that Berlanese uses the Latin alphabet. Vowel letters are "a", "o", "u", "i", and "e". Other letters are consonant.
In Berlanese, there has to be a vowel after every consonant, but there can be any letter after any vowel. The only exception is a consonant "n"; after this letter, there can be any letter (not only a vowel) or there can be no letter at all. For example, the words "harakiri", "yupie", "man", and "nbo" are Berlanese while the words "horse", "king", "my", and "nz" are not.
Help Vitya find out if a word s is Berlanese.
Input
The first line of the input contains the string s consisting of |s| (1β€ |s|β€ 100) lowercase Latin letters.
Output
Print "YES" (without quotes) if there is a vowel after every consonant except "n", otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
sumimasen
Output
YES
Input
ninja
Output
YES
Input
codeforces
Output
NO
Note
In the first and second samples, a vowel goes after each consonant except "n", so the word is Berlanese.
In the third sample, the consonant "c" goes after the consonant "r", and the consonant "s" stands on the end, so the word is not Berlanese.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
s=input()
a=['a','e','i','o','u']
c=0
for i in range(len(s)):
if(i==len(s)-1):
if s[i] in a or s[i]=='n':
c+=1
continue
elif s[i] in a:
c+=1
continue
elif(s[i]=='n'):
c+=1
continue
else:
if s[i+1] in a:
c+=1
continue
if(c==len(s)):
print("YES")
else:
print("NO")
``` | vfc_34229 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "codeforces\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "ninja\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "sumimasen\n",
"output": "YES\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "s\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "d\n",
"output": "NO\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1030_F. Putting Boxes Together | Solve the following coding problem using the programming language python:
There is an infinite line consisting of cells. There are n boxes in some cells of this line. The i-th box stands in the cell a_i and has weight w_i. All a_i are distinct, moreover, a_{i - 1} < a_i holds for all valid i.
You would like to put together some boxes. Putting together boxes with indices in the segment [l, r] means that you will move some of them in such a way that their positions will form some segment [x, x + (r - l)].
In one step you can move any box to a neighboring cell if it isn't occupied by another box (i.e. you can choose i and change a_i by 1, all positions should remain distinct). You spend w_i units of energy moving the box i by one cell. You can move any box any number of times, in arbitrary order.
Sometimes weights of some boxes change, so you have queries of two types:
1. id nw β weight w_{id} of the box id becomes nw.
2. l r β you should compute the minimum total energy needed to put together boxes with indices in [l, r]. Since the answer can be rather big, print the remainder it gives when divided by 1000 000 007 = 10^9 + 7. Note that the boxes are not moved during the query, you only should compute the answer.
Note that you should minimize the answer, not its remainder modulo 10^9 + 7. So if you have two possible answers 2 β
10^9 + 13 and 2 β
10^9 + 14, you should choose the first one and print 10^9 + 6, even though the remainder of the second answer is 0.
Input
The first line contains two integers n and q (1 β€ n, q β€ 2 β
10^5) β the number of boxes and the number of queries.
The second line contains n integers a_1, a_2, ... a_n (1 β€ a_i β€ 10^9) β the positions of the boxes. All a_i are distinct, a_{i - 1} < a_i holds for all valid i.
The third line contains n integers w_1, w_2, ... w_n (1 β€ w_i β€ 10^9) β the initial weights of the boxes.
Next q lines describe queries, one query per line.
Each query is described in a single line, containing two integers x and y. If x < 0, then this query is of the first type, where id = -x, nw = y (1 β€ id β€ n, 1 β€ nw β€ 10^9). If x > 0, then the query is of the second type, where l = x and r = y (1 β€ l_j β€ r_j β€ n). x can not be equal to 0.
Output
For each query of the second type print the answer on a separate line. Since answer can be large, print the remainder it gives when divided by 1000 000 007 = 10^9 + 7.
Example
Input
5 8
1 2 6 7 10
1 1 1 1 2
1 1
1 5
1 3
3 5
-3 5
-1 10
1 4
2 5
Output
0
10
3
4
18
7
Note
Let's go through queries of the example:
1. 1\ 1 β there is only one box so we don't need to move anything.
2. 1\ 5 β we can move boxes to segment [4, 8]: 1 β
|1 - 4| + 1 β
|2 - 5| + 1 β
|6 - 6| + 1 β
|7 - 7| + 2 β
|10 - 8| = 10.
3. 1\ 3 β we can move boxes to segment [1, 3].
4. 3\ 5 β we can move boxes to segment [7, 9].
5. -3\ 5 β w_3 is changed from 1 to 5.
6. -1\ 10 β w_1 is changed from 1 to 10. The weights are now equal to w = [10, 1, 5, 1, 2].
7. 1\ 4 β we can move boxes to segment [1, 4].
8. 2\ 5 β we can move boxes to segment [5, 8].
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_34233 | {
"difficulty": "12",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 500000000}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5 8\n1 2 6 7 10\n1 1 1 1 2\n1 1\n1 5\n1 3\n3 5\n-3 5\n-1 10\n1 4\n2 5\n",
"output": "0\n10\n3\n4\n18\n7\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10 10\n4 5 6 7 8 11 14 15 17 19\n1 4 12 10 13 20 14 20 13 16\n-7 16\n1 1\n7 9\n1 4\n4 8\n3 8\n-1 10\n2 4\n-9 1\n5 9\n",
"output": "0\n13\n0\n118\n142\n0\n93\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 3\n1 3\n1 3\n1 2\n-1 3\n1 2\n",
"output": "1\n3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10 10\n4 6 8 9 10 14 16 21 27 30\n24 27 3 14 3 24 6 12 15 28\n-4 6\n4 10\n-2 30\n-9 25\n1 8\n1 3\n2 9\n-3 16\n-2 24\n1 10\n",
"output": "487\n270\n27\n472\n943\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3 3\n351772224 464078370 812738126\n149252109 153315732 540915058\n1 2\n-3 861733588\n-1 190898187\n",
"output": "877576309\n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 1053_D. Linear Congruential Generator | Solve the following coding problem using the programming language python:
You are given a tuple generator f^{(k)} = (f_1^{(k)}, f_2^{(k)}, ..., f_n^{(k)}), where f_i^{(k)} = (a_i β
f_i^{(k - 1)} + b_i) mod p_i and f^{(0)} = (x_1, x_2, ..., x_n). Here x mod y denotes the remainder of x when divided by y. All p_i are primes.
One can see that with fixed sequences x_i, y_i, a_i the tuples f^{(k)} starting from some index will repeat tuples with smaller indices. Calculate the maximum number of different tuples (from all f^{(k)} for k β₯ 0) that can be produced by this generator, if x_i, a_i, b_i are integers in the range [0, p_i - 1] and can be chosen arbitrary. The answer can be large, so print the remainder it gives when divided by 10^9 + 7
Input
The first line contains one integer n (1 β€ n β€ 2 β
10^5) β the number of elements in the tuple.
The second line contains n space separated prime numbers β the modules p_1, p_2, β¦, p_n (2 β€ p_i β€ 2 β
10^6).
Output
Print one integer β the maximum number of different tuples modulo 10^9 + 7.
Examples
Input
4
2 3 5 7
Output
210
Input
3
5 3 3
Output
30
Note
In the first example we can choose next parameters: a = [1, 1, 1, 1], b = [1, 1, 1, 1], x = [0, 0, 0, 0], then f_i^{(k)} = k mod p_i.
In the second example we can choose next parameters: a = [1, 1, 2], b = [1, 1, 0], x = [0, 0, 1].
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_34237 | {
"difficulty": "10",
"memory_limit": null,
"memory_limit_bytes": 512000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n2 3 5 7\n",
"output": "210\n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 1075_E. Optimal Polygon Perimeter | Solve the following coding problem using the programming language python:
You are given n points on the plane. The polygon formed from all the n points is strictly convex, that is, the polygon is convex, and there are no three collinear points (i.e. lying in the same straight line). The points are numbered from 1 to n, in clockwise order.
We define the distance between two points p_1 = (x_1, y_1) and p_2 = (x_2, y_2) as their Manhattan distance: $$$d(p_1, p_2) = |x_1 - x_2| + |y_1 - y_2|.$$$
Furthermore, we define the perimeter of a polygon, as the sum of Manhattan distances between all adjacent pairs of points on it; if the points on the polygon are ordered as p_1, p_2, β¦, p_k (k β₯ 3), then the perimeter of the polygon is d(p_1, p_2) + d(p_2, p_3) + β¦ + d(p_k, p_1).
For some parameter k, let's consider all the polygons that can be formed from the given set of points, having any k vertices, such that the polygon is not self-intersecting. For each such polygon, let's consider its perimeter. Over all such perimeters, we define f(k) to be the maximal perimeter.
Please note, when checking whether a polygon is self-intersecting, that the edges of a polygon are still drawn as straight lines. For instance, in the following pictures:
<image>
In the middle polygon, the order of points (p_1, p_3, p_2, p_4) is not valid, since it is a self-intersecting polygon. The right polygon (whose edges resemble the Manhattan distance) has the same order and is not self-intersecting, but we consider edges as straight lines. The correct way to draw this polygon is (p_1, p_2, p_3, p_4), which is the left polygon.
Your task is to compute f(3), f(4), β¦, f(n). In other words, find the maximum possible perimeter for each possible number of points (i.e. 3 to n).
Input
The first line contains a single integer n (3 β€ n β€ 3β
10^5) β the number of points.
Each of the next n lines contains two integers x_i and y_i (-10^8 β€ x_i, y_i β€ 10^8) β the coordinates of point p_i.
The set of points is guaranteed to be convex, all points are distinct, the points are ordered in clockwise order, and there will be no three collinear points.
Output
For each i (3β€ iβ€ n), output f(i).
Examples
Input
4
2 4
4 3
3 0
1 3
Output
12 14
Input
3
0 0
0 2
2 0
Output
8
Note
In the first example, for f(3), we consider four possible polygons:
* (p_1, p_2, p_3), with perimeter 12.
* (p_1, p_2, p_4), with perimeter 8.
* (p_1, p_3, p_4), with perimeter 12.
* (p_2, p_3, p_4), with perimeter 12.
For f(4), there is only one option, taking all the given points. Its perimeter 14.
In the second example, there is only one possible polygon. Its perimeter is 8.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
n = int(input())
north = -100000000
south = 100000000
east = -100000000
west = 100000000
ne = -200000000
nw = -200000000
se = -200000000
sw = -200000000
for i in range(n):
x,y = map(int,input().split())
north = max(north,y)
east = max(east,x)
south = min(south,y)
west = min(west,x)
ne = max(ne,x+y)
nw = max(nw,y-x)
se = max(se,x-y)
sw = max(sw,-1*x-y)
best = 2*(ne-south-west)
best = max(best,2*(nw-south+east))
best = max(best,2*(se+north-west))
best = max(best,2*(sw+north+east))
ans = str(best)
peri = 2*(north-south+east-west)
ans += (" "+str(peri))*(n-3)
print(ans)
``` | vfc_34241 | {
"difficulty": "11",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n2 4\n4 3\n3 0\n1 3\n",
"output": "12 14 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n0 0\n0 2\n2 0\n",
"output": "8 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n97972354 -510322\n97972814 -510361\n97972410 -510528\n",
"output": "1332 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "12\n-83240790 -33942371\n-83240805 -33942145\n-83240821 -33941752\n-83240424 -33941833\n-83240107 -33942105\n-83239958 -33942314\n-83239777 -33942699\n-83239762 -33942925\n-83239746 -33943318\n-83240143 -33943237\n-83240460 -33942965\n-83240609 -33942756\n",
"output": "5282 5282 5282 5282 5282 5282 5282 5282 5282 5282 ",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1096_F. Inversion Expectation | Solve the following coding problem using the programming language python:
A permutation of size n is an array of size n such that each integer from 1 to n occurs exactly once in this array. An inversion in a permutation p is a pair of indices (i, j) such that i > j and a_i < a_j. For example, a permutation [4, 1, 3, 2] contains 4 inversions: (2, 1), (3, 1), (4, 1), (4, 3).
You are given a permutation p of size n. However, the numbers on some positions are replaced by -1. Let the valid permutation be such a replacement of -1 in this sequence back to numbers from 1 to n in such a way that the resulting sequence is a permutation of size n.
The given sequence was turned into a valid permutation randomly with the equal probability of getting each valid permutation.
Calculate the expected total number of inversions in the resulting valid permutation.
It can be shown that it is in the form of P/Q where P and Q are non-negative integers and Q β 0. Report the value of P β
Q^{-1} \pmod {998244353}.
Input
The first line contains a single integer n (1 β€ n β€ 2 β
10^5) β the length of the sequence.
The second line contains n integers p_1, p_2, ..., p_n (-1 β€ p_i β€ n, p_i β 0) β the initial sequence.
It is guaranteed that all elements not equal to -1 are pairwise distinct.
Output
Print a single integer β the expected total number of inversions in the resulting valid permutation.
It can be shown that it is in the form of P/Q where P and Q are non-negative integers and Q β 0. Report the value of P β
Q^{-1} \pmod {998244353}.
Examples
Input
3
3 -1 -1
Output
499122179
Input
2
1 2
Output
0
Input
2
-1 -1
Output
499122177
Note
In the first example two resulting valid permutations are possible:
* [3, 1, 2] β 2 inversions;
* [3, 2, 1] β 3 inversions.
The expected value is (2 β
1 + 3 β
1)/(2) = 2.5.
In the second example no -1 are present, thus the only valid permutation is possible β the given one. It has 0 inversions.
In the third example there are two resulting valid permutations β one with 0 inversions and one with 1 inversion.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
base=998244353;
def power(x, y):
if(y==0):
return 1
t=power(x, y//2)
t=(t*t)%base
if(y%2):
t=(t*x)%base
return t;
def inverse(x):
return power(x, base-2)
ft=[0]
for i in range(0, 200000):
ft.append(0)
def get(i):
res=0
while(i<=200000):
res+=ft[i]
i+=i&-i
return res
def update(i, x):
while(i):
ft[i]+=x
i-=i&-i
n=int(input())
a=[0]
a+=list(map(int, input().split()))
neg=[0]
non=[0]
for i in range(1, n+1):
non.append(0)
for i in range(1, n+1):
if(a[i]!=-1):
non[a[i]]+=1
for i in range(1, n+1):
non[i]+=non[i-1]
for i in range(1, n+1):
if(a[i]==-1):
neg.append(neg[i-1]+1)
else:
neg.append(neg[i-1])
m=neg[n]
ans=0
for i in range(1, n+1):
if(a[i]!=-1):
ans+=get(a[i])
update(a[i], 1)
fm=1
fs=fm
for i in range(1, m+1):
fs=fm
fm=(fm*i)%base
fs=(fs*inverse(fm))%base
for i in range(1, n+1):
if(a[i]!=-1):
less=a[i]-non[a[i]]
more=m-less
ans=(ans+neg[i]*more*fs)%base
ans=(ans+(m-neg[i])*less*fs)%base
ans=(ans+m*(m-1)*inverse(4))%base
print(ans)
``` | vfc_34245 | {
"difficulty": "12",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n1 2\n",
"output": " 0",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1117_G. Recursive Queries | Solve the following coding problem using the programming language python:
You are given a permutation p_1, p_2, ..., p_n. You should answer q queries. Each query is a pair (l_i, r_i), and you should calculate f(l_i, r_i).
Let's denote m_{l, r} as the position of the maximum in subsegment p_l, p_{l+1}, ..., p_r.
Then f(l, r) = (r - l + 1) + f(l, m_{l,r} - 1) + f(m_{l,r} + 1, r) if l β€ r or 0 otherwise.
Input
The first line contains two integers n and q (1 β€ n β€ 10^6, 1 β€ q β€ 10^6) β the size of the permutation p and the number of queries.
The second line contains n pairwise distinct integers p_1, p_2, ..., p_n (1 β€ p_i β€ n, p_i β p_j for i β j) β permutation p.
The third line contains q integers l_1, l_2, ..., l_q β the first parts of the queries.
The fourth line contains q integers r_1, r_2, ..., r_q β the second parts of the queries.
It's guaranteed that 1 β€ l_i β€ r_i β€ n for all queries.
Output
Print q integers β the values f(l_i, r_i) for the corresponding queries.
Example
Input
4 5
3 1 4 2
2 1 1 2 1
2 3 4 4 1
Output
1 6 8 5 1
Note
Description of the queries:
1. f(2, 2) = (2 - 2 + 1) + f(2, 1) + f(3, 2) = 1 + 0 + 0 = 1;
2. f(1, 3) = (3 - 1 + 1) + f(1, 2) + f(4, 3) = 3 + (2 - 1 + 1) + f(1, 0) + f(2, 2) = 3 + 2 + (2 - 2 + 1) = 6;
3. f(1, 4) = (4 - 1 + 1) + f(1, 2) + f(4, 4) = 4 + 3 + 1 = 8;
4. f(2, 4) = (4 - 2 + 1) + f(2, 2) + f(4, 4) = 3 + 1 + 1 = 5;
5. f(1, 1) = (1 - 1 + 1) + 0 + 0 = 1.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_34249 | {
"difficulty": "13",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 4, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4 5\n3 1 4 2\n2 1 1 2 1\n2 3 4 4 1\n",
"output": "1 6 8 5 1 \n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 5\n3 1 4 2\n2 2 1 2 1\n2 3 4 4 1\n",
"output": " 1 3 8 5 1 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 5\n3 1 4 2\n2 2 1 3 1\n2 3 4 4 1\n",
"output": " 1 3 8 3 1 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 5\n3 1 4 2\n2 2 1 3 1\n2 4 4 4 1\n",
"output": " 1 5 8 3 1 ",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 5\n3 1 4 2\n2 4 1 3 1\n2 4 4 4 1\n",
"output": " 1 1 8 3 1 ",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 1144_C. Two Shuffled Sequences | Solve the following coding problem using the programming language python:
Two integer sequences existed initially β one of them was strictly increasing, and the other one β strictly decreasing.
Strictly increasing sequence is a sequence of integers [x_1 < x_2 < ... < x_k]. And strictly decreasing sequence is a sequence of integers [y_1 > y_2 > ... > y_l]. Note that the empty sequence and the sequence consisting of one element can be considered as increasing or decreasing.
They were merged into one sequence a. After that sequence a got shuffled. For example, some of the possible resulting sequences a for an increasing sequence [1, 3, 4] and a decreasing sequence [10, 4, 2] are sequences [1, 2, 3, 4, 4, 10] or [4, 2, 1, 10, 4, 3].
This shuffled sequence a is given in the input.
Your task is to find any two suitable initial sequences. One of them should be strictly increasing and the other one β strictly decreasing. Note that the empty sequence and the sequence consisting of one element can be considered as increasing or decreasing.
If there is a contradiction in the input and it is impossible to split the given sequence a to increasing and decreasing sequences, print "NO".
Input
The first line of the input contains one integer n (1 β€ n β€ 2 β
10^5) β the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (0 β€ a_i β€ 2 β
10^5), where a_i is the i-th element of a.
Output
If there is a contradiction in the input and it is impossible to split the given sequence a to increasing and decreasing sequences, print "NO" in the first line.
Otherwise print "YES" in the first line and any two suitable sequences. Note that the empty sequence and the sequence consisting of one element can be considered as increasing or decreasing.
In the second line print n_i β the number of elements in the strictly increasing sequence. n_i can be zero, in this case the increasing sequence is empty.
In the third line print n_i integers inc_1, inc_2, ..., inc_{n_i} in the increasing order of its values (inc_1 < inc_2 < ... < inc_{n_i}) β the strictly increasing sequence itself. You can keep this line empty if n_i = 0 (or just print the empty line).
In the fourth line print n_d β the number of elements in the strictly decreasing sequence. n_d can be zero, in this case the decreasing sequence is empty.
In the fifth line print n_d integers dec_1, dec_2, ..., dec_{n_d} in the decreasing order of its values (dec_1 > dec_2 > ... > dec_{n_d}) β the strictly decreasing sequence itself. You can keep this line empty if n_d = 0 (or just print the empty line).
n_i + n_d should be equal to n and the union of printed sequences should be a permutation of the given sequence (in case of "YES" answer).
Examples
Input
7
7 2 7 3 3 1 4
Output
YES
2
3 7
5
7 4 3 2 1
Input
5
4 3 1 5 3
Output
YES
1
3
4
5 4 3 1
Input
5
1 1 2 1 2
Output
NO
Input
5
0 1 2 3 4
Output
YES
0
5
4 3 2 1 0
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
n = int(input())
a = [int(s) for s in input().split()]
d = dict()
for i in a:
x = d.get(i,0)
if x == 0:
d[i] = 1
else:
d[i] += 1
up = []
down = []
for i in d.keys():
k = d[i]
if k == 1:
up.append(i)
elif k == 2:
up.append(i)
down.append(i)
else:
print('NO')
exit()
up.sort()
down.sort(reverse = True)
print('YES')
print(len(up))
print(' '.join([str(i) for i in up]))
print(len(down))
print(' '.join([str(i) for i in down]))
``` | vfc_34253 | {
"difficulty": "9",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n4 3 1 5 3\n",
"output": "YES\n4\n1 3 4 5\n1\n3\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1165_B. Polycarp Training | Solve the following coding problem using the programming language python:
Polycarp wants to train before another programming competition. During the first day of his training he should solve exactly 1 problem, during the second day β exactly 2 problems, during the third day β exactly 3 problems, and so on. During the k-th day he should solve k problems.
Polycarp has a list of n contests, the i-th contest consists of a_i problems. During each day Polycarp has to choose exactly one of the contests he didn't solve yet and solve it. He solves exactly k problems from this contest. Other problems are discarded from it. If there are no contests consisting of at least k problems that Polycarp didn't solve yet during the k-th day, then Polycarp stops his training.
How many days Polycarp can train if he chooses the contests optimally?
Input
The first line of the input contains one integer n (1 β€ n β€ 2 β
10^5) β the number of contests.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 2 β
10^5) β the number of problems in the i-th contest.
Output
Print one integer β the maximum number of days Polycarp can train if he chooses the contests optimally.
Examples
Input
4
3 1 4 1
Output
3
Input
3
1 1 1
Output
1
Input
5
1 1 1 2 2
Output
2
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
a = int(input())
b = [int(x) for x in input().split()]
b.sort()
s = 1
q = 0
for i in b:
if i >= s:
s += 1
q += 1
print(q)
``` | vfc_34257 | {
"difficulty": "8",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "4\n3 1 4 1\n",
"output": "3\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n1 1 1 2 2\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1219_I. The Light Square | Solve the following coding problem using the programming language python:
For her birthday Alice received an interesting gift from her friends β The Light Square. The Light Square game is played on an N Γ N lightbulbs square board with a magical lightbulb bar of size N Γ 1 that has magical properties. At the start of the game some lights on the square board and magical bar are turned on. The goal of the game is to transform the starting light square board pattern into some other pattern using the magical bar without rotating the square board. The magical bar works as follows:
It can be placed on any row or column
The orientation of the magical lightbulb must be left to right or top to bottom for it to keep its magical properties
The entire bar needs to be fully placed on a board
The lights of the magical bar never change
If the light on the magical bar is the same as the light of the square it is placed on it will switch the light on the square board off, otherwise it will switch the light on
The magical bar can be used an infinite number of times
Alice has a hard time transforming her square board into the pattern Bob gave her. Can you help her transform the board or let her know it is impossible? If there are multiple solutions print any.
Input
The first line contains one positive integer number N\ (1 β€ N β€ 2000) representing the size of the square board.
The next N lines are strings of length N consisting of 1's and 0's representing the initial state of the square board starting from the top row. If the character in a string is 1 it means the light is turned on, otherwise it is off.
The next N lines are strings of length N consisting of 1's and 0's representing the desired state of the square board starting from the top row that was given to Alice by Bob.
The last line is one string of length N consisting of 1's and 0's representing the pattern of the magical bar in a left to right order.
Output
Transform the instructions for Alice in order to transform the square board into the pattern Bob gave her. The first line of the output contains an integer number M\ (0 β€ M β€ 10^5) representing the number of times Alice will need to apply the magical bar.
The next M lines are of the form "col X" or "row X", where X is 0-based index of the matrix, meaning the magical bar should be applied to either row X or column X. If there is no solution, print only -1. In case of multiple solutions print any correct one.
Examples
Input
2
11
11
00
01
11
Output
-1
Input
2
10
00
00
00
10
Output
1
row 0
Input
3
110
011
100
100
011
100
100
Output
3
row 0
col 0
col 1
Note
Example 1: It is impossible to transform square board from one format to another
Example 2: Magic bar can be applied on first row or column.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
N = input()
a, b = [], []
for n in range(N) : a.append(raw_input())
for n in range(N) : b.append(raw_input())
wand = raw_input()
piv = -1 if wand.count('1') == 0 else wand.index('1')
def getVar(ca, row, col) :
v = int(a[row][col]) ^ (int(wand[row])*ca[col])
if v == v ^ int(wand[col]) :
if v == int(b[row][col]) : return None
else : return False
return v != int(b[row][col])
if piv < 0 : print 0 if a == b else -1
else :
rowActions, colActions = [], []
for n in range(N) :
if a[piv][n] != b[piv][n] : colActions.append(1)
else : colActions.append(0)
#print "colActions = ", colActions
possible = True
for n in range(N) :
inv = getVar(colActions, n, 0)
#print inv
for m in range(1,N) :
v = getVar(colActions, n, m)
#print inv, v
if v is not None and inv is None : inv = v
if inv is not None and v is not None and inv != v :
possible = False
rowActions.append(1 if inv else 0)
#if not possible : break
#print "rowActions = ", rowActions
if possible :
print sum(rowActions) + sum(colActions)
for r in range(len(rowActions)) :
if rowActions[r] : print "row", r
for c in range(len(colActions)) :
if colActions[c] : print "col", c
else : print -1
``` | vfc_34269 | {
"difficulty": "15",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n110\n011\n100\n100\n011\n100\n100\n",
"output": "1\ncol 1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n11\n11\n00\n01\n11\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n10\n00\n00\n00\n10\n",
"output": "1\ncol 0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n10\n10\n01\n01\n10\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n100\n100\n111\n000\n000\n000\n101\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n10\n11\n00\n00\n11\n",
"output": "-1\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1244_D. Paint the Tree | Solve the following coding problem using the programming language python:
You are given a tree consisting of n vertices. A tree is an undirected connected acyclic graph.
<image> Example of a tree.
You have to paint each vertex into one of three colors. For each vertex, you know the cost of painting it in every color.
You have to paint the vertices so that any path consisting of exactly three distinct vertices does not contain any vertices with equal colors. In other words, let's consider all triples (x, y, z) such that x β y, y β z, x β z, x is connected by an edge with y, and y is connected by an edge with z. The colours of x, y and z should be pairwise distinct. Let's call a painting which meets this condition good.
You have to calculate the minimum cost of a good painting and find one of the optimal paintings. If there is no good painting, report about it.
Input
The first line contains one integer n (3 β€ n β€ 100 000) β the number of vertices.
The second line contains a sequence of integers c_{1, 1}, c_{1, 2}, ..., c_{1, n} (1 β€ c_{1, i} β€ 10^{9}), where c_{1, i} is the cost of painting the i-th vertex into the first color.
The third line contains a sequence of integers c_{2, 1}, c_{2, 2}, ..., c_{2, n} (1 β€ c_{2, i} β€ 10^{9}), where c_{2, i} is the cost of painting the i-th vertex into the second color.
The fourth line contains a sequence of integers c_{3, 1}, c_{3, 2}, ..., c_{3, n} (1 β€ c_{3, i} β€ 10^{9}), where c_{3, i} is the cost of painting the i-th vertex into the third color.
Then (n - 1) lines follow, each containing two integers u_j and v_j (1 β€ u_j, v_j β€ n, u_j β v_j) β the numbers of vertices connected by the j-th undirected edge. It is guaranteed that these edges denote a tree.
Output
If there is no good painting, print -1.
Otherwise, print the minimum cost of a good painting in the first line. In the second line print n integers b_1, b_2, ..., b_n (1 β€ b_i β€ 3), where the i-th integer should denote the color of the i-th vertex. If there are multiple good paintings with minimum cost, print any of them.
Examples
Input
3
3 2 3
4 3 2
3 1 3
1 2
2 3
Output
6
1 3 2
Input
5
3 4 2 1 2
4 2 1 5 4
5 3 2 1 1
1 2
3 2
4 3
5 3
Output
-1
Input
5
3 4 2 1 2
4 2 1 5 4
5 3 2 1 1
1 2
3 2
4 3
5 4
Output
9
1 3 2 1 3
Note
All vertices should be painted in different colors in the first example. The optimal way to do it is to paint the first vertex into color 1, the second vertex β into color 3, and the third vertex β into color 2. The cost of this painting is 3 + 2 + 1 = 6.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import sys
from collections import defaultdict,deque
def getcost(ind,col1,col2,col3,count):
#print(ind,'ind',count,'count')
if count==1:
#print(col1[ind-1],'collooorr')
return col1[ind-1]
if count==2:
#print(col2[ind-1],'colllllooorrr')
return col2[ind-1]
#print(col3[ind-1],'cpppplll')
return col3[ind-1]
n=int(sys.stdin.readline())
col1=list(map(int,sys.stdin.readline().split()))
col2=list(map(int,sys.stdin.readline().split()))
col3=list(map(int,sys.stdin.readline().split()))
tree=defaultdict(list)
for i in range(n-1):
u,v=map(int,sys.stdin.readline().split())
tree[u].append(v)
tree[v].append(u)
z=True
leaf=[]
for i in tree:
if len(tree[i])>2:
print(-1)
z=False
break
if len(tree[i])==1:
leaf.append(i)
if z:
dp=defaultdict(list)
for i in range(1,n+1):
dp[i]=[float('inf'),float('inf'),float('inf')]
#print(leaf,'leaf')
#for t in range(len(leaf)):
l=[[1,2,3],[1,3,2],[2,3,1],[2,1,3],[3,1,2],[3,2,1]]
m=[0,0,0,0,0,0]
color=[[-1 for _ in range(n)] for x in range(6)]
for j in range(6):
count=0
cost=0
start=leaf[0]
vis=defaultdict(int)
vis[start]=1
q=deque()
q.append(start)
color[j][start-1]=l[j][count%3]
cost+=getcost(start,col1,col2,col3,l[j][count%3])
#print(l[j][count%3],'check')
count+=1
while q:
#print(q,'q')
a=q.popleft()
for i in tree[a]:
#print(i,'i')
if vis[i]==0:
#print(l[j][count%3],'check')
q.append(i)
#print(i,'i')
vis[i]=1
color[j][i-1]=l[j][count%3]
cost+=getcost(i,col1,col2,col3,l[j][count%3])
count+=1
m[j]=cost
#print(cost,'cost')
#print('----')
#print(m,'m')
ind=-1
ans=min(m)
print(ans)
#print(color,'color')
for i in range(6):
if m[i]==ans:
break
'''color=[-1 for _ in range(n)]
count=0
vis=defaultdict(int)
q=deque()
q.append(leaf[0])
vis[leaf[0]]=1
color[leaf[0]-1]=l[i][count%3]
count+=1
while q:
a=q.popleft()
for j in tree[a]:
if vis[j]==0:
q.append(j)
vis[j]=1
color[j-1]=l[i][count%3]
count+=1
print(ans)'''
print(*color[i])
``` | vfc_34273 | {
"difficulty": "10",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 3, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5\n3 4 2 1 2\n4 2 1 5 4\n5 3 2 1 1\n1 2\n3 2\n4 3\n5 3\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n3 4 2 1 2\n4 2 1 5 4\n5 3 2 1 1\n1 2\n3 2\n4 3\n5 4\n",
"output": "9\n1 3 2 1 3 \n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1264_B. Beautiful Sequence | Solve the following coding problem using the programming language python:
An integer sequence is called beautiful if the difference between any two consecutive numbers is equal to 1. More formally, a sequence s_1, s_2, β¦, s_{n} is beautiful if |s_i - s_{i+1}| = 1 for all 1 β€ i β€ n - 1.
Trans has a numbers 0, b numbers 1, c numbers 2 and d numbers 3. He wants to construct a beautiful sequence using all of these a + b + c + d numbers.
However, it turns out to be a non-trivial task, and Trans was not able to do it. Could you please help Trans?
Input
The only input line contains four non-negative integers a, b, c and d (0 < a+b+c+d β€ 10^5).
Output
If it is impossible to construct a beautiful sequence satisfying the above constraints, print "NO" (without quotes) in one line.
Otherwise, print "YES" (without quotes) in the first line. Then in the second line print a + b + c + d integers, separated by spaces β a beautiful sequence. There should be a numbers equal to 0, b numbers equal to 1, c numbers equal to 2 and d numbers equal to 3.
If there are multiple answers, you can print any of them.
Examples
Input
2 2 2 1
Output
YES
0 1 0 1 2 3 2
Input
1 2 3 4
Output
NO
Input
2 2 2 3
Output
NO
Note
In the first test, it is easy to see, that the sequence is beautiful because the difference between any two consecutive numbers is equal to 1. Also, there are exactly two numbers, equal to 0, 1, 2 and exactly one number, equal to 3.
It can be proved, that it is impossible to construct beautiful sequences in the second and third tests.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
# from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var): sys.stdout.write(' '.join(map(str, var)) + '\n')
def out(var): sys.stdout.write(str(var) + '\n')
from decimal import Decimal
# from fractions import Fraction
# sys.setrecursionlimit(100000)
mod = int(1e9) + 7
INF=10**8
a,b,c,d=mdata()
ans=[]
if a + (1 if (c or d) else 0) - b > 1 or d + (1 if (a or b) else 0) - c > 1 or abs(a+c-b-d)>1:
out('NO')
exit()
if a+c-b<d and b:
ans.append(1)
b-=1
for i in range(min(a,b)):
ans.append(0)
ans.append(1)
if a>b:
ans.append(0)
b-=min(a,b)
for i in range(min(b,c)):
ans.append(2)
ans.append(1)
c-=b
for i in range(min(d,c)):
ans.append(2)
ans.append(3)
if c>d:
ans.append(2)
elif d>c:
ans=[3]+ans
out("YES")
outl(ans)
``` | vfc_34277 | {
"difficulty": "8",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "1 2 3 4\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 2 2 3\n",
"output": "NO\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 2 2 1\n",
"output": "YES\n0 1 0 1 2 3 2 \n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1285_D. Dr. Evil Underscores | Solve the following coding problem using the programming language python:
Today, as a friendship gift, Bakry gave Badawy n integers a_1, a_2, ..., a_n and challenged him to choose an integer X such that the value \underset{1 β€ i β€ n}{max} (a_i β X) is minimum possible, where β denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
As always, Badawy is too lazy, so you decided to help him and find the minimum possible value of \underset{1 β€ i β€ n}{max} (a_i β X).
Input
The first line contains integer n (1β€ n β€ 10^5).
The second line contains n integers a_1, a_2, ..., a_n (0 β€ a_i β€ 2^{30}-1).
Output
Print one integer β the minimum possible value of \underset{1 β€ i β€ n}{max} (a_i β X).
Examples
Input
3
1 2 3
Output
2
Input
2
1 5
Output
4
Note
In the first sample, we can choose X = 3.
In the second sample, we can choose X = 5.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
def solve(nums, bit):
if bit < 0: return 0
l = []
r = []
for el in nums:
if ((el >> bit) & 1): r.append(el)
else: l.append(el)
if len(l) == 0: return solve(r, bit - 1)
if len(r) == 0: return solve(l, bit - 1)
return min(solve(l, bit - 1), solve(r, bit - 1)) + (1 << bit)
n = int(input())
nums = map(int, input().split())
print(solve(nums, 30))
``` | vfc_34281 | {
"difficulty": "10",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n1 5\n",
"output": "4",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "3\n1 2 3\n",
"output": "2",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\n1073741823\n",
"output": "0",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n0 1073741823\n",
"output": "536870912",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n1073741823 1073741823 1073741823 1073741823 1073741823\n",
"output": "0",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1329_A. Dreamoon Likes Coloring | Solve the following coding problem using the programming language python:
Dreamoon likes coloring cells very much.
There is a row of n cells. Initially, all cells are empty (don't contain any color). Cells are numbered from 1 to n.
You are given an integer m and m integers l_1, l_2, β¦, l_m (1 β€ l_i β€ n)
Dreamoon will perform m operations.
In i-th operation, Dreamoon will choose a number p_i from range [1, n-l_i+1] (inclusive) and will paint all cells from p_i to p_i+l_i-1 (inclusive) in i-th color. Note that cells may be colored more one than once, in this case, cell will have the color from the latest operation.
Dreamoon hopes that after these m operations, all colors will appear at least once and all cells will be colored. Please help Dreamoon to choose p_i in each operation to satisfy all constraints.
Input
The first line contains two integers n,m (1 β€ m β€ n β€ 100 000).
The second line contains m integers l_1, l_2, β¦, l_m (1 β€ l_i β€ n).
Output
If it's impossible to perform m operations to satisfy all constraints, print "'-1" (without quotes).
Otherwise, print m integers p_1, p_2, β¦, p_m (1 β€ p_i β€ n - l_i + 1), after these m operations, all colors should appear at least once and all cells should be colored.
If there are several possible solutions, you can print any.
Examples
Input
5 3
3 2 2
Output
2 4 1
Input
10 1
1
Output
-1
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
n,m=map(int,input().split())
b=list(map(int,input().split()))
if sum(b)<n:print(-1)
else:
s=n+1;r=[-1]*m;i=0
for j in b[::-1]:
s=max(s-j,m-i)
if s+j-1>n:print(-1);break
r[i]=s;i+=1
else:print(*r[::-1])
``` | vfc_34289 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "10 1\n1\n",
"output": "-1",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5 3\n3 2 2\n",
"output": "1 2 4 ",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1349_A. Orac and LCM | Solve the following coding problem using the programming language python:
For the multiset of positive integers s=\\{s_1,s_2,...,s_k\}, define the Greatest Common Divisor (GCD) and Least Common Multiple (LCM) of s as follow:
* \gcd(s) is the maximum positive integer x, such that all integers in s are divisible on x.
* lcm(s) is the minimum positive integer x, that divisible on all integers from s.
For example, \gcd(\{8,12\})=4,\gcd(\{12,18,6\})=6 and lcm(\{4,6\})=12. Note that for any positive integer x, \gcd(\\{x\})=lcm(\\{x\})=x.
Orac has a sequence a with length n. He come up with the multiset t=\{lcm(\\{a_i,a_j\})\ |\ i<j\}, and asked you to find the value of \gcd(t) for him. In other words, you need to calculate the GCD of LCMs of all pairs of elements in the given sequence.
Input
The first line contains one integer n\ (2β€ nβ€ 100 000).
The second line contains n integers, a_1, a_2, β¦, a_n (1 β€ a_i β€ 200 000).
Output
Print one integer: \gcd(\{lcm(\\{a_i,a_j\})\ |\ i<j\}).
Examples
Input
2
1 1
Output
1
Input
4
10 24 40 80
Output
40
Input
10
540 648 810 648 720 540 594 864 972 648
Output
54
Note
For the first example, t=\{lcm(\{1,1\})\}=\{1\}, so \gcd(t)=1.
For the second example, t=\{120,40,80,120,240,80\}, and it's not hard to see that \gcd(t)=40.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
from collections import Counter
from math import floor, sqrt
try:
long
except NameError:
long = int
def fac(n):
step = lambda x: 1 + (x<<2) - ((x>>1)<<1)
maxq = long(floor(sqrt(n)))
d = 1
q = 2 if n % 2 == 0 else 3
while q <= maxq and n % q != 0:
q = step(d)
d += 1
return [q] + fac(n // q) if q <= maxq else [n]
for _ in range(1):
n=int(input())
li=list(map(int,input().split()))
e=[[] for i in range(200007)]
#f=[30 for i in range(200007)]
#g=[0 for i in range(200007)]
d=[0 for i in range(200007)]
for i in li:
k=Counter(fac(i))
for j in k:
e[j].append(k[j])
d[j]+=1
ans=1
for i in range(200007):
if d[i]==n:
p=min(e[i])
f=30
o=0
for l in e[i]:
if l!=p:
o+=1
f=min(f,l)
if o==n-1:
p=f
ans*=i**(p)
#print(i,p)
if d[i]==n-1:
ans*=i**min(e[i])
print(ans)
``` | vfc_34293 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 3, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "2\n1 1\n",
"output": "1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n540 648 810 648 720 540 594 864 972 648\n",
"output": "54\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n10 24 40 80\n",
"output": "40\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2\n10007 20014\n",
"output": "20014\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1391_D. 505 | Solve the following coding problem using the programming language python:
A binary matrix is called good if every even length square sub-matrix has an odd number of ones.
Given a binary matrix a consisting of n rows and m columns, determine the minimum number of cells you need to change to make it good, or report that there is no way to make it good at all.
All the terms above have their usual meanings β refer to the Notes section for their formal definitions.
Input
The first line of input contains two integers n and m (1 β€ n β€ m β€ 10^6 and nβ
m β€ 10^6) β the number of rows and columns in a, respectively.
The following n lines each contain m characters, each of which is one of 0 and 1. If the j-th character on the i-th line is 1, then a_{i,j} = 1. Similarly, if the j-th character on the i-th line is 0, then a_{i,j} = 0.
Output
Output the minimum number of cells you need to change to make a good, or output -1 if it's not possible at all.
Examples
Input
3 3
101
001
110
Output
2
Input
7 15
000100001010010
100111010110001
101101111100100
010000111111010
111010010100001
000011001111101
111111011010011
Output
-1
Note
In the first case, changing a_{1,1} to 0 and a_{2,2} to 1 is enough.
You can verify that there is no way to make the matrix in the second case good.
Some definitions β
* A binary matrix is one in which every element is either 1 or 0.
* A sub-matrix is described by 4 parameters β r_1, r_2, c_1, and c_2; here, 1 β€ r_1 β€ r_2 β€ n and 1 β€ c_1 β€ c_2 β€ m.
* This sub-matrix contains all elements a_{i,j} that satisfy both r_1 β€ i β€ r_2 and c_1 β€ j β€ c_2.
* A sub-matrix is, further, called an even length square if r_2-r_1 = c_2-c_1 and r_2-r_1+1 is divisible by 2.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
def f( l, a):
i, count = 0,0
for x in l:
count += x not in a[i]
#print( x, a[i], count )
i = (i+1) %2
return count
def g( l, mx ):
return min( [ f(l,mx[i]) for i in range(len(mx)) ] )
def two():
l = [ x[0]+x[1] for x in zip(input(),input())]
mx = (
[['00','11'],['10','01']] ,
[['10','01'],['00','11']] )
return g(l,mx)
def three():
l = [ x[0]+x[1]+x[2] for x in zip(input(),input(),input())]
mx = (
[['100','011'],['110','001']] ,
[['110','001'],['100','011']] ,
[['111','000'],['010','101']] ,
[['010','101'],['000','111']] )
return g(l,mx)
nm = input()
n,m = [ int(x) for x in nm.split() ]
if n == 1:
print(0)
exit()
if n > 3:
print( -1 )
exit()
if n == 2:
print( two() )
exit()
if n == 3:
print( three() )
exit()
``` | vfc_34301 | {
"difficulty": "10",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 3\n101\n001\n110\n",
"output": "2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "7 15\n000100001010010\n100111010110001\n101101111100100\n010000111111010\n111010010100001\n000011001111101\n111111011010011\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 58\n1100001110010010100001000000000110110001101001100010101110\n1110110010101111001110010001100010001010100011111110110100\n",
"output": "27\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4 4\n1100\n0011\n1100\n0011\n",
"output": "-1\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 1\n0\n",
"output": "0\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 1\n1\n",
"output": "0\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1431_J. Zero-XOR Array | Solve the following coding problem using the programming language python:
You are given an array of integers a of size n. This array is non-decreasing, i. e. a_1 β€ a_2 β€ ... β€ a_n.
You have to find arrays of integers b of size 2n - 1, such that:
* b_{2i-1} = a_i (1 β€ i β€ n);
* array b is non-decreasing;
* b_1 β b_2 β ... β b_{2n-1} = 0 (β denotes bitwise XOR operation: <https://en.wikipedia.org/wiki/Exclusive_or>. In Kotlin, it is xor function).
Calculate the number of arrays that meet all the above conditions, modulo 998244353.
Input
The first line contains a single integer n (2 β€ n β€ 17) β the size of the array a.
The second line contains n integers (0 β€ a_i β€ 2^{60} - 1; a_i β€ a_{i+1}) β elements of the array a.
Output
Print a single integer β the number of arrays that meet all the above conditions, modulo 998244353.
Examples
Input
3
0 1 3
Output
2
Input
4
0 3 6 7
Output
6
Input
5
1 5 9 10 23
Output
20
Input
10
39 62 64 79 81 83 96 109 120 122
Output
678132
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_34309 | {
"difficulty": "16",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 6, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n0 1 3\n",
"output": "\n2\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "4\n0 3 6 7\n",
"output": "\n6\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "5\n1 5 9 10 23\n",
"output": "\n20\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10\n39 62 64 79 81 83 96 109 120 122\n",
"output": "\n678132\n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 1455_G. Forbidden Value | Solve the following coding problem using the programming language python:
Polycarp is editing a complicated computer program. First, variable x is declared and assigned to 0. Then there are instructions of two types:
1. set y v β assign x a value y or spend v burles to remove that instruction (thus, not reassign x);
2. if y ... end block β execute instructions inside the if block if the value of x is y and ignore the block otherwise.
if blocks can contain set instructions and other if blocks inside them.
However, when the value of x gets assigned to s, the computer breaks and immediately catches fire. Polycarp wants to prevent that from happening and spend as few burles as possible.
What is the minimum amount of burles he can spend on removing set instructions to never assign x to s?
Input
The first line contains two integers n and s (1 β€ n β€ 2 β
10^5, 1 β€ s β€ 2 β
10^5) β the number of lines in the program and the forbidden value of x.
The following n lines describe the program. Each line is one of three types:
1. set y v (0 β€ y β€ 2 β
10^5, 1 β€ v β€ 10^9);
2. if y (0 β€ y β€ 2 β
10^5);
3. end.
Each if instruction is matched by an end instruction. Each end instruction has an if instruction to match.
Output
Print a single integer β the minimum amount of burles Polycarp can spend on removing set instructions to never assign x to s.
Examples
Input
5 1
set 1 10
set 2 15
if 2
set 1 7
end
Output
17
Input
7 2
set 3 4
if 3
set 10 4
set 2 7
set 10 1
end
set 4 2
Output
4
Input
9 200
if 0
set 5 5
if 5
set 100 13
end
if 100
set 200 1
end
end
Output
1
Input
1 10
set 1 15
Output
0
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | vfc_34313 | {
"difficulty": "13",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "5 1\nset 1 10\nset 2 15\nif 2\nset 1 7\nend\n",
"output": "\n17\n",
"type": "stdin_stdout"
}
]
} |
|
code_contests | verifiable_code | 1506_G. Maximize the Remaining String | Solve the following coding problem using the programming language python:
You are given a string s, consisting of lowercase Latin letters. While there is at least one character in the string s that is repeated at least twice, you perform the following operation:
* you choose the index i (1 β€ i β€ |s|) such that the character at position i occurs at least two times in the string s, and delete the character at position i, that is, replace s with s_1 s_2 β¦ s_{i-1} s_{i+1} s_{i+2} β¦ s_n.
For example, if s="codeforces", then you can apply the following sequence of operations:
* i=6 β s="codefrces";
* i=1 β s="odefrces";
* i=7 β s="odefrcs";
Given a given string s, find the lexicographically maximum string that can be obtained after applying a certain sequence of operations after which all characters in the string become unique.
A string a of length n is lexicographically less than a string b of length m, if:
* there is an index i (1 β€ i β€ min(n, m)) such that the first i-1 characters of the strings a and b are the same, and the i-th character of the string a is less than i-th character of string b;
* or the first min(n, m) characters in the strings a and b are the same and n < m.
For example, the string a="aezakmi" is lexicographically less than the string b="aezus".
Input
The first line contains one integer t (1 β€ t β€ 10^4). Then t test cases follow.
Each test case is characterized by a string s, consisting of lowercase Latin letters (1 β€ |s| β€ 2 β
10^5).
It is guaranteed that the sum of the lengths of the strings in all test cases does not exceed 2 β
10^5.
Output
For each test case, output the lexicographically maximum string that can be obtained after applying a certain sequence of operations after which all characters in the string become unique.
Example
Input
6
codeforces
aezakmi
abacaba
convexhull
swflldjgpaxs
myneeocktxpqjpz
Output
odfrces
ezakmi
cba
convexhul
wfldjgpaxs
myneocktxqjpz
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
for _ in range(int(input())):
s = input(); stack = []; seen = set(); last_occurrence = {c: i for i, c in enumerate(s)}
for i, c in enumerate(s):
if c not in seen:
while stack and c > stack[-1] and i < last_occurrence[stack[-1]]: seen.discard(stack.pop())
seen.add(c); stack.append(c)
print(''.join(stack))
``` | vfc_34321 | {
"difficulty": "13",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 500000000}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "6\ncodeforces\naezakmi\nabacaba\nconvexhull\nswflldjgpaxs\nmyneeocktxpqjpz\n",
"output": "\nodfrces\nezakmi\ncba\nconvexhul\nwfldjgpaxs\nmyneocktxqjpz\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n",
"output": "a\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n",
"output": "ba\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "6\nsecrofedoc\naezakmi\nabacaba\nconvexhull\nswflldjgpaxs\nmyneeocktxpqjpz\n",
"output": "srofedc\nezakmi\ncba\nconvexhul\nwfldjgpaxs\nmyneocktxqjpz\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 1534_A. Colour the Flag | Solve the following coding problem using the programming language python:
Today we will be playing a red and white colouring game (no, this is not the Russian Civil War; these are just the colours of the Canadian flag).
You are given an n Γ m grid of "R", "W", and "." characters. "R" is red, "W" is white and "." is blank. The neighbours of a cell are those that share an edge with it (those that only share a corner do not count).
Your job is to colour the blank cells red or white so that every red cell only has white neighbours (and no red ones) and every white cell only has red neighbours (and no white ones). You are not allowed to recolour already coloured cells.
Input
The first line contains t (1 β€ t β€ 100), the number of test cases.
In each test case, the first line will contain n (1 β€ n β€ 50) and m (1 β€ m β€ 50), the height and width of the grid respectively.
The next n lines will contain the grid. Each character of the grid is either 'R', 'W', or '.'.
Output
For each test case, output "YES" if there is a valid grid or "NO" if there is not.
If there is, output the grid on the next n lines. If there are multiple answers, print any.
In the output, the "YES"s and "NO"s are case-insensitive, meaning that outputs such as "yEs" and "nO" are valid. However, the grid is case-sensitive.
Example
Input
3
4 6
.R....
......
......
.W....
4 4
.R.W
....
....
....
5 1
R
W
R
W
R
Output
YES
WRWRWR
RWRWRW
WRWRWR
RWRWRW
NO
YES
R
W
R
W
R
Note
The answer for the first example case is given in the example output, and it can be proven that no grid exists that satisfies the requirements of the second example case. In the third example all cells are initially coloured, and the colouring is valid.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
I=input
for _ in[0]*int(I()):
s=set();n,m=map(int,I().split());i=5
for _ in[0]*n:
i^=5;j=5
for x in I():j^=5;s|=(s,{ord(x)^i^j})[x>'.']
if len(s)<2:
c=s and s.pop()or 82
r=('YES',*(''.join(chr(c^((i^j)&1)*5)for i in range(m))for j in range(n)))
else:r='NO',
print(*r)
``` | vfc_34325 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 500000000}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3\n4 6\n.R....\n......\n......\n.W....\n4 4\n.R.W\n....\n....\n....\n5 1\nR\nW\nR\nW\nR\n",
"output": "\nYES\nWRWRWR\nRWRWRW\nWRWRWR\nRWRWRW\nNO\nYES\nR\nW\nR\nW\nR\n",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 180_E. Cubes | Solve the following coding problem using the programming language python:
Let's imagine that you're playing the following simple computer game. The screen displays n lined-up cubes. Each cube is painted one of m colors. You are allowed to delete not more than k cubes (that do not necessarily go one after another). After that, the remaining cubes join together (so that the gaps are closed) and the system counts the score. The number of points you score equals to the length of the maximum sequence of cubes of the same color that follow consecutively. Write a program that determines the maximum possible number of points you can score.
Remember, you may delete no more than k any cubes. It is allowed not to delete cubes at all.
Input
The first line contains three integers n, m and k (1 β€ n β€ 2Β·105, 1 β€ m β€ 105, 0 β€ k < n). The second line contains n integers from 1 to m β the numbers of cube colors. The numbers of colors are separated by single spaces.
Output
Print the maximum possible number of points you can score.
Examples
Input
10 3 2
1 2 1 1 3 2 1 1 2 2
Output
4
Input
10 2 2
1 2 1 2 1 1 2 1 1 2
Output
5
Input
3 1 2
1 1 1
Output
3
Note
In the first sample you should delete the fifth and the sixth cubes.
In the second sample you should delete the fourth and the seventh cubes.
In the third sample you shouldn't delete any cubes.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
avl=AvlTree()
#-----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default='z', func=lambda a, b: min(a ,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left)/ 2)
# Check if middle element is
# less than or equal to key
if (arr[mid]<=key):
count = mid+1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def countGreater( arr,n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n,m,k=map(int,input().split())
l=list(map(int,input().split()))
ans=1
ind=defaultdict(list)
for i in range(n):
ind[l[i]].append(i)
#print(ind)
cop=k
for i in ind:
if len(ind[i])==1:
continue
st=0
r=0
k=cop
while(r<len(ind[i])-1):
#print(k)
if k>=0:
ans=max(ans,r-st+1)
r+=1
k -= ind[i][r] - ind[i][r - 1] - 1
else:
st += 1
k += ind[i][st] - ind[i][st - 1]-1
#print(st,r,i,k)
if k>=0:
ans=max(ans,r-st+1)
print(ans)
``` | vfc_34333 | {
"difficulty": "11",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 1, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "3 1 2\n1 1 1\n",
"output": "3",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10 2 2\n1 2 1 2 1 1 2 1 1 2\n",
"output": "5",
"type": "stdin_stdout"
}
]
} |
code_contests | verifiable_code | 204_A. Little Elephant and Interval | Solve the following coding problem using the programming language python:
The Little Elephant very much loves sums on intervals.
This time he has a pair of integers l and r (l β€ r). The Little Elephant has to find the number of such integers x (l β€ x β€ r), that the first digit of integer x equals the last one (in decimal notation). For example, such numbers as 101, 477474 or 9 will be included in the answer and 47, 253 or 1020 will not.
Help him and count the number of described numbers x for a given pair l and r.
Input
The single line contains a pair of integers l and r (1 β€ l β€ r β€ 1018) β the boundaries of the interval.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
On a single line print a single integer β the answer to the problem.
Examples
Input
2 47
Output
12
Input
47 1024
Output
98
Note
In the first sample the answer includes integers 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44.
The input will be given via stdin and the output should be printed to stdout by your code.
Now solve the problem by providing the code. | ```python
def F (x) :
if (x < 10) :
return x
rv = 9
tmp = x
len = 0
while (tmp > 0) :
len += 1
tmp = tmp // 10
d = int (x // pow(10, len-1))
tmp = 1
for i in range(len - 2) :
rv += 9 * tmp
tmp *= 10
for i in range (1, 10) :
if (i < d) :
rv += 1 * tmp
if (x // (pow(10, len-1)) <= x % 10) :
rv += 1
rv += (x % (pow(10, len - 1))) // 10
return rv
l, r = map(int, input().split())
print( abs(F(r) - F(l-1)))
# author: Ashwin Ginoria
# email: [email protected]
# 123456789012345678
# 100000000000000000
# 1000000000000000000
``` | vfc_34337 | {
"difficulty": "7",
"memory_limit": null,
"memory_limit_bytes": 256000000,
"problem_url": null,
"time_limit": "{'seconds': 2, 'nanos': 0}"
} | {
"language": "python",
"test_cases": [
{
"fn_name": null,
"input": "47 1024\n",
"output": "98\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "2 47\n",
"output": "12\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "645762257531682046 885295120956158518\n",
"output": "23953286342447648\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "1 11\n",
"output": "10\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "47 8545\n",
"output": "849\n",
"type": "stdin_stdout"
},
{
"fn_name": null,
"input": "10001 10000002\n",
"output": "999001\n",
"type": "stdin_stdout"
}
]
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.