message stringlengths 2 39.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 450 109k | cluster float64 2 2 | __index_level_0__ int64 900 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova promised himself that he would never play computer games... But recently Firestorm — a well-known game developing company — published their newest game, World of Farcraft, and it became really popular. Of course, Vova started playing it.
Now he tries to solve a quest. The task is to come to a settlement named Overcity and spread a rumor in it.
Vova knows that there are n characters in Overcity. Some characters are friends to each other, and they share information they got. Also Vova knows that he can bribe each character so he or she starts spreading the rumor; i-th character wants ci gold in exchange for spreading the rumor. When a character hears the rumor, he tells it to all his friends, and they start spreading the rumor to their friends (for free), and so on.
The quest is finished when all n characters know the rumor. What is the minimum amount of gold Vova needs to spend in order to finish the quest?
Take a look at the notes if you think you haven't understood the problem completely.
Input
The first line contains two integer numbers n and m (1 ≤ n ≤ 105, 0 ≤ m ≤ 105) — the number of characters in Overcity and the number of pairs of friends.
The second line contains n integer numbers ci (0 ≤ ci ≤ 109) — the amount of gold i-th character asks to start spreading the rumor.
Then m lines follow, each containing a pair of numbers (xi, yi) which represent that characters xi and yi are friends (1 ≤ xi, yi ≤ n, xi ≠ yi). It is guaranteed that each pair is listed at most once.
Output
Print one number — the minimum amount of gold Vova has to spend in order to finish the quest.
Examples
Input
5 2
2 5 3 4 8
1 4
4 5
Output
10
Input
10 0
1 2 3 4 5 6 7 8 9 10
Output
55
Input
10 5
1 6 2 7 3 8 4 9 5 10
1 2
3 4
5 6
7 8
9 10
Output
15
Note
In the first example the best decision is to bribe the first character (he will spread the rumor to fourth character, and the fourth one will spread it to fifth). Also Vova has to bribe the second and the third characters, so they know the rumor.
In the second example Vova has to bribe everyone.
In the third example the optimal decision is to bribe the first, the third, the fifth, the seventh and the ninth characters.
Submitted Solution:
```
import collections
def bfs(visited,sv,arr):
q=collections.deque([sv])
visited[sv]=True
A=[]
while q:
front=q.popleft()
A.append(arr[front])
for i in graph[front]:
if not visited[i]:
q.append(i)
visited[i]=True
if A:
return min(A)
else:
return 0
def solve(graph,arr,n):
visited=[False for _ in range(n)]
ans=0
for i in range(n):
if not visited[i]:
ans+=bfs(visited,i,arr)
return ans
n,m=map(int,input().split())
arr=list(map(int,input().split()))
if m==0:
print(sum(arr))
else:
graph=[[] for _ in range(n)]
for i in range(m):
a,b=map(int,input().split())
a-=1
b-=1
graph[a].append(b)
graph[b].append(a)
print(solve(graph,arr,n))
``` | instruction | 0 | 40,920 | 2 | 81,840 |
Yes | output | 1 | 40,920 | 2 | 81,841 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova promised himself that he would never play computer games... But recently Firestorm — a well-known game developing company — published their newest game, World of Farcraft, and it became really popular. Of course, Vova started playing it.
Now he tries to solve a quest. The task is to come to a settlement named Overcity and spread a rumor in it.
Vova knows that there are n characters in Overcity. Some characters are friends to each other, and they share information they got. Also Vova knows that he can bribe each character so he or she starts spreading the rumor; i-th character wants ci gold in exchange for spreading the rumor. When a character hears the rumor, he tells it to all his friends, and they start spreading the rumor to their friends (for free), and so on.
The quest is finished when all n characters know the rumor. What is the minimum amount of gold Vova needs to spend in order to finish the quest?
Take a look at the notes if you think you haven't understood the problem completely.
Input
The first line contains two integer numbers n and m (1 ≤ n ≤ 105, 0 ≤ m ≤ 105) — the number of characters in Overcity and the number of pairs of friends.
The second line contains n integer numbers ci (0 ≤ ci ≤ 109) — the amount of gold i-th character asks to start spreading the rumor.
Then m lines follow, each containing a pair of numbers (xi, yi) which represent that characters xi and yi are friends (1 ≤ xi, yi ≤ n, xi ≠ yi). It is guaranteed that each pair is listed at most once.
Output
Print one number — the minimum amount of gold Vova has to spend in order to finish the quest.
Examples
Input
5 2
2 5 3 4 8
1 4
4 5
Output
10
Input
10 0
1 2 3 4 5 6 7 8 9 10
Output
55
Input
10 5
1 6 2 7 3 8 4 9 5 10
1 2
3 4
5 6
7 8
9 10
Output
15
Note
In the first example the best decision is to bribe the first character (he will spread the rumor to fourth character, and the fourth one will spread it to fifth). Also Vova has to bribe the second and the third characters, so they know the rumor.
In the second example Vova has to bribe everyone.
In the third example the optimal decision is to bribe the first, the third, the fifth, the seventh and the ninth characters.
Submitted Solution:
```
from collections import defaultdict
import sys
def dfs(i,ans):
stack=[]
m=10**18
stack.append(i)
while stack:
v=stack.pop()
if visited[v]:
continue
visited[v]=True
m=min(m,coin[v-1])
for u in d[v]:
if not visited[u]:
stack.append(u)
return m
input=sys.stdin.buffer.readline
n,m=map(int,input().split())
coin=list(map(int,input().split()))
d=defaultdict(list)
for _ in range(m):
u,v=map(int,input().split())
d[u].append(v)
d[v].append(u)
visited=[False for i in range(n+1)]
ans=0
for i in range(1,n+1):
if not visited[i]:
ans+=dfs(i,ans)
print(ans)
``` | instruction | 0 | 40,921 | 2 | 81,842 |
Yes | output | 1 | 40,921 | 2 | 81,843 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova promised himself that he would never play computer games... But recently Firestorm — a well-known game developing company — published their newest game, World of Farcraft, and it became really popular. Of course, Vova started playing it.
Now he tries to solve a quest. The task is to come to a settlement named Overcity and spread a rumor in it.
Vova knows that there are n characters in Overcity. Some characters are friends to each other, and they share information they got. Also Vova knows that he can bribe each character so he or she starts spreading the rumor; i-th character wants ci gold in exchange for spreading the rumor. When a character hears the rumor, he tells it to all his friends, and they start spreading the rumor to their friends (for free), and so on.
The quest is finished when all n characters know the rumor. What is the minimum amount of gold Vova needs to spend in order to finish the quest?
Take a look at the notes if you think you haven't understood the problem completely.
Input
The first line contains two integer numbers n and m (1 ≤ n ≤ 105, 0 ≤ m ≤ 105) — the number of characters in Overcity and the number of pairs of friends.
The second line contains n integer numbers ci (0 ≤ ci ≤ 109) — the amount of gold i-th character asks to start spreading the rumor.
Then m lines follow, each containing a pair of numbers (xi, yi) which represent that characters xi and yi are friends (1 ≤ xi, yi ≤ n, xi ≠ yi). It is guaranteed that each pair is listed at most once.
Output
Print one number — the minimum amount of gold Vova has to spend in order to finish the quest.
Examples
Input
5 2
2 5 3 4 8
1 4
4 5
Output
10
Input
10 0
1 2 3 4 5 6 7 8 9 10
Output
55
Input
10 5
1 6 2 7 3 8 4 9 5 10
1 2
3 4
5 6
7 8
9 10
Output
15
Note
In the first example the best decision is to bribe the first character (he will spread the rumor to fourth character, and the fourth one will spread it to fifth). Also Vova has to bribe the second and the third characters, so they know the rumor.
In the second example Vova has to bribe everyone.
In the third example the optimal decision is to bribe the first, the third, the fifth, the seventh and the ninth characters.
Submitted Solution:
```
n,m = map(int,input().split())
a = list(map(int,input().split()))
f = [0 for i in range(n)]
for i in range(m):
x,y = map(int,input().split())
f[y-1] = 1
ans = 0
for i in range(n):
if(f[i]==0):
ans+=a[i]
print(ans)
``` | instruction | 0 | 40,922 | 2 | 81,844 |
No | output | 1 | 40,922 | 2 | 81,845 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova promised himself that he would never play computer games... But recently Firestorm — a well-known game developing company — published their newest game, World of Farcraft, and it became really popular. Of course, Vova started playing it.
Now he tries to solve a quest. The task is to come to a settlement named Overcity and spread a rumor in it.
Vova knows that there are n characters in Overcity. Some characters are friends to each other, and they share information they got. Also Vova knows that he can bribe each character so he or she starts spreading the rumor; i-th character wants ci gold in exchange for spreading the rumor. When a character hears the rumor, he tells it to all his friends, and they start spreading the rumor to their friends (for free), and so on.
The quest is finished when all n characters know the rumor. What is the minimum amount of gold Vova needs to spend in order to finish the quest?
Take a look at the notes if you think you haven't understood the problem completely.
Input
The first line contains two integer numbers n and m (1 ≤ n ≤ 105, 0 ≤ m ≤ 105) — the number of characters in Overcity and the number of pairs of friends.
The second line contains n integer numbers ci (0 ≤ ci ≤ 109) — the amount of gold i-th character asks to start spreading the rumor.
Then m lines follow, each containing a pair of numbers (xi, yi) which represent that characters xi and yi are friends (1 ≤ xi, yi ≤ n, xi ≠ yi). It is guaranteed that each pair is listed at most once.
Output
Print one number — the minimum amount of gold Vova has to spend in order to finish the quest.
Examples
Input
5 2
2 5 3 4 8
1 4
4 5
Output
10
Input
10 0
1 2 3 4 5 6 7 8 9 10
Output
55
Input
10 5
1 6 2 7 3 8 4 9 5 10
1 2
3 4
5 6
7 8
9 10
Output
15
Note
In the first example the best decision is to bribe the first character (he will spread the rumor to fourth character, and the fourth one will spread it to fifth). Also Vova has to bribe the second and the third characters, so they know the rumor.
In the second example Vova has to bribe everyone.
In the third example the optimal decision is to bribe the first, the third, the fifth, the seventh and the ninth characters.
Submitted Solution:
```
import sys
def find(n,list2):
r = n
while(list2[r] != r):
r = list2[r]
i = n
while(i != r):
temp = list2[i]
list2[i] = r
i = temp
return r
def join(a,b,list1):
x = find(a,list1)
y = find(b,list1)
if x != y:
list1[y] = x
def main():
sum = 0
p = sys.stdin.readline().strip('\n')
if p == '':
return
n,m = map(int,p.split(' '))
list2 = [i for i in range(n)]
p = sys.stdin.readline().strip('\n')
list1 = [i for i in map(int,p.split(' '))]
#print(list1)
for i in range(m):
a,b = map(int,sys.stdin.readline().strip('\n').split(' '))
join(a - 1,b - 1,list2)
#print(list2)
for i in range(n):
a = find(i,list2)
list1[i] = min(list1[i],list1[a])
for i in range(n):
if i == find(i,list2):
sum += list1[i]
print(sum)
if __name__ == '__main__':
main()
``` | instruction | 0 | 40,923 | 2 | 81,846 |
No | output | 1 | 40,923 | 2 | 81,847 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova promised himself that he would never play computer games... But recently Firestorm — a well-known game developing company — published their newest game, World of Farcraft, and it became really popular. Of course, Vova started playing it.
Now he tries to solve a quest. The task is to come to a settlement named Overcity and spread a rumor in it.
Vova knows that there are n characters in Overcity. Some characters are friends to each other, and they share information they got. Also Vova knows that he can bribe each character so he or she starts spreading the rumor; i-th character wants ci gold in exchange for spreading the rumor. When a character hears the rumor, he tells it to all his friends, and they start spreading the rumor to their friends (for free), and so on.
The quest is finished when all n characters know the rumor. What is the minimum amount of gold Vova needs to spend in order to finish the quest?
Take a look at the notes if you think you haven't understood the problem completely.
Input
The first line contains two integer numbers n and m (1 ≤ n ≤ 105, 0 ≤ m ≤ 105) — the number of characters in Overcity and the number of pairs of friends.
The second line contains n integer numbers ci (0 ≤ ci ≤ 109) — the amount of gold i-th character asks to start spreading the rumor.
Then m lines follow, each containing a pair of numbers (xi, yi) which represent that characters xi and yi are friends (1 ≤ xi, yi ≤ n, xi ≠ yi). It is guaranteed that each pair is listed at most once.
Output
Print one number — the minimum amount of gold Vova has to spend in order to finish the quest.
Examples
Input
5 2
2 5 3 4 8
1 4
4 5
Output
10
Input
10 0
1 2 3 4 5 6 7 8 9 10
Output
55
Input
10 5
1 6 2 7 3 8 4 9 5 10
1 2
3 4
5 6
7 8
9 10
Output
15
Note
In the first example the best decision is to bribe the first character (he will spread the rumor to fourth character, and the fourth one will spread it to fifth). Also Vova has to bribe the second and the third characters, so they know the rumor.
In the second example Vova has to bribe everyone.
In the third example the optimal decision is to bribe the first, the third, the fifth, the seventh and the ninth characters.
Submitted Solution:
```
n,k=map(int,input().split())
s,t,xxx=list(map(int,input().split())),[{}],0
while k>0:
a,ok=list(map(int,input().split())),False
for i in t:
if a[0] in i:
i.add(a[1])
ok=True
if ok==False:
t.append(set(a))
k-=1
del t[0]
if len(t)>0:
for i in t:
xxx+=s[min(i)-1]
for ii in i:
s[ii-1]=0
print(xxx+sum(s))
``` | instruction | 0 | 40,924 | 2 | 81,848 |
No | output | 1 | 40,924 | 2 | 81,849 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova promised himself that he would never play computer games... But recently Firestorm — a well-known game developing company — published their newest game, World of Farcraft, and it became really popular. Of course, Vova started playing it.
Now he tries to solve a quest. The task is to come to a settlement named Overcity and spread a rumor in it.
Vova knows that there are n characters in Overcity. Some characters are friends to each other, and they share information they got. Also Vova knows that he can bribe each character so he or she starts spreading the rumor; i-th character wants ci gold in exchange for spreading the rumor. When a character hears the rumor, he tells it to all his friends, and they start spreading the rumor to their friends (for free), and so on.
The quest is finished when all n characters know the rumor. What is the minimum amount of gold Vova needs to spend in order to finish the quest?
Take a look at the notes if you think you haven't understood the problem completely.
Input
The first line contains two integer numbers n and m (1 ≤ n ≤ 105, 0 ≤ m ≤ 105) — the number of characters in Overcity and the number of pairs of friends.
The second line contains n integer numbers ci (0 ≤ ci ≤ 109) — the amount of gold i-th character asks to start spreading the rumor.
Then m lines follow, each containing a pair of numbers (xi, yi) which represent that characters xi and yi are friends (1 ≤ xi, yi ≤ n, xi ≠ yi). It is guaranteed that each pair is listed at most once.
Output
Print one number — the minimum amount of gold Vova has to spend in order to finish the quest.
Examples
Input
5 2
2 5 3 4 8
1 4
4 5
Output
10
Input
10 0
1 2 3 4 5 6 7 8 9 10
Output
55
Input
10 5
1 6 2 7 3 8 4 9 5 10
1 2
3 4
5 6
7 8
9 10
Output
15
Note
In the first example the best decision is to bribe the first character (he will spread the rumor to fourth character, and the fourth one will spread it to fifth). Also Vova has to bribe the second and the third characters, so they know the rumor.
In the second example Vova has to bribe everyone.
In the third example the optimal decision is to bribe the first, the third, the fifth, the seventh and the ninth characters.
Submitted Solution:
```
n, m = map(int, input().split())
costs = [int(x) for x in input().split()]
disjointSet = [-1 for x in costs]
def root(x):
if disjointSet[x] > 0:
disjointSet[x] = root(disjointSet[x])
return disjointSet[x]
return x
for _ in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
r1, r2 = root(a), root(b)
if r1 != r2:
disjointSet[r2] = r1
costs[r1] = min(costs[r1], costs[r2])
costs[r2] = 0
print(sum(costs))
``` | instruction | 0 | 40,925 | 2 | 81,850 |
No | output | 1 | 40,925 | 2 | 81,851 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya’s elder brother Petya loves playing computer games. In one of his favourite computer games Petya reached the final level where a fight with the boss take place.
While playing the game Petya found spell scrolls and now he is about to use them. Let’s describe the way fighting goes on this level:
1) The boss has two parameters: max — the initial amount of health and reg — regeneration rate per second.
2) Every scroll also has two parameters: powi — spell power measured in percents — the maximal amount of health counted off the initial one, which allows to use the scroll (i.e. if the boss has more than powi percent of health the scroll cannot be used); and dmgi the damage per second inflicted upon the boss if the scroll is used. As soon as a scroll is used it disappears and another spell is cast upon the boss that inflicts dmgi of damage per second upon him until the end of the game.
During the battle the actions per second are performed in the following order: first the boss gets the damage from all the spells cast upon him, then he regenerates reg of health (at the same time he can’t have more than max of health), then the player may use another scroll (no more than one per second).
The boss is considered to be defeated if at the end of a second he has nonpositive ( ≤ 0) amount of health.
Help Petya to determine whether he can win with the set of scrolls available to him and if he can, determine the minimal number of seconds he needs to do it.
Input
The first line contains three integers N, max and reg (1 ≤ N, max, reg ≤ 1000) –– the amount of scrolls and the parameters of the boss. The next N lines contain two integers powi and dmgi each — the parameters of the i-th scroll (0 ≤ powi ≤ 100, 1 ≤ dmgi ≤ 2000).
Output
In case Petya can’t complete this level, output in the single line NO.
Otherwise, output on the first line YES. On the second line output the minimal time after which the boss can be defeated and the number of used scrolls. In the next lines for each used scroll output space-separated number of seconds passed from the start of the battle to the moment the scroll was used and the number of the scroll. Scrolls are numbered starting from 1 in the input order. The first scroll is considered to be available to be used after 0 seconds.
Output scrolls in the order they were used. It is not allowed to use scrolls after the boss is defeated.
Examples
Input
2 10 3
100 3
99 1
Output
NO
Input
2 100 10
100 11
90 9
Output
YES
19 2
0 1
10 2 | instruction | 0 | 41,553 | 2 | 83,106 |
Tags: greedy, implementation
Correct Solution:
```
class Scroll:
def __init__(self, id, power, damage):
self.id = id
self.power = power
self.damage = damage
self.active = False
num_scrolls, boss_max, regenerate = map(int, input().split())
scrolls = [Scroll(i+1, *map(int, input().split())) for i in range(num_scrolls)]
scrolls.sort(key = lambda scroll: -scroll.damage)
boss_curr = boss_max
scroll_damage = 0
active_scrolls = []
tick = 0
while True:
boss_prev = boss_curr
boss_curr -= scroll_damage
boss_curr = min(boss_max, boss_curr + regenerate)
if boss_curr <= 0:
print('YES')
print(tick, len(active_scrolls))
for scroll in active_scrolls:
print(scroll.start, scroll.id)
break
found = False
for scroll in scrolls:
if not scroll.active and 100*boss_curr <= scroll.power*boss_max:
scroll.start = tick
scroll.active = True
active_scrolls.append(scroll)
scroll_damage += scroll.damage
found = True
break
if not found and boss_curr >= boss_prev:
print('NO')
break
tick += 1
# Made By Mostafa_Khaled
``` | output | 1 | 41,553 | 2 | 83,107 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya’s elder brother Petya loves playing computer games. In one of his favourite computer games Petya reached the final level where a fight with the boss take place.
While playing the game Petya found spell scrolls and now he is about to use them. Let’s describe the way fighting goes on this level:
1) The boss has two parameters: max — the initial amount of health and reg — regeneration rate per second.
2) Every scroll also has two parameters: powi — spell power measured in percents — the maximal amount of health counted off the initial one, which allows to use the scroll (i.e. if the boss has more than powi percent of health the scroll cannot be used); and dmgi the damage per second inflicted upon the boss if the scroll is used. As soon as a scroll is used it disappears and another spell is cast upon the boss that inflicts dmgi of damage per second upon him until the end of the game.
During the battle the actions per second are performed in the following order: first the boss gets the damage from all the spells cast upon him, then he regenerates reg of health (at the same time he can’t have more than max of health), then the player may use another scroll (no more than one per second).
The boss is considered to be defeated if at the end of a second he has nonpositive ( ≤ 0) amount of health.
Help Petya to determine whether he can win with the set of scrolls available to him and if he can, determine the minimal number of seconds he needs to do it.
Input
The first line contains three integers N, max and reg (1 ≤ N, max, reg ≤ 1000) –– the amount of scrolls and the parameters of the boss. The next N lines contain two integers powi and dmgi each — the parameters of the i-th scroll (0 ≤ powi ≤ 100, 1 ≤ dmgi ≤ 2000).
Output
In case Petya can’t complete this level, output in the single line NO.
Otherwise, output on the first line YES. On the second line output the minimal time after which the boss can be defeated and the number of used scrolls. In the next lines for each used scroll output space-separated number of seconds passed from the start of the battle to the moment the scroll was used and the number of the scroll. Scrolls are numbered starting from 1 in the input order. The first scroll is considered to be available to be used after 0 seconds.
Output scrolls in the order they were used. It is not allowed to use scrolls after the boss is defeated.
Examples
Input
2 10 3
100 3
99 1
Output
NO
Input
2 100 10
100 11
90 9
Output
YES
19 2
0 1
10 2 | instruction | 0 | 41,554 | 2 | 83,108 |
Tags: greedy, implementation
Correct Solution:
```
spell_used = 0
parameters = input().split()
num_spell = int(parameters[0])
max_pow = int(parameters[1])
reg_rate = int(parameters[2])
input_spell = [0 for i in range(num_spell)]
spell = [0 for i in range(num_spell)]
power = [0 for i in range(num_spell)]
dmg = [0 for i in range(num_spell)]
for i in range(num_spell):
input_spell[i]=input()
spell[i]= input_spell[i].split()
for i in range(num_spell):
power[i]= int(spell[i][0])
dmg[i] = int(spell[i][1])
seconds = 0
new_spell = 0
curr_spell_dmg = 0
new_max_pow = max_pow
eligible_pow = []
eligible_dmg = []
ind=[]
spell_num=[]
list_of_spell_used=[]
spell_used_time = []
while (new_max_pow>0):
for i in range(len(power)):
if power[i]*max_pow >= new_max_pow*100:
eligible_pow.append(power[i])
eligible_dmg.append(dmg[i])
ind.append(i)
power = [i for j, i in enumerate(power) if j not in ind]
dmg = [i for j, i in enumerate(dmg) if j not in ind]
ind = []
if len(eligible_pow) != 0:
new_spell = eligible_dmg.index(max(eligible_dmg))
spell_used = spell_used + 1
list_of_spell_used.append(str(eligible_pow[new_spell])+" "+str(eligible_dmg[new_spell]))
spell_used_time.append(seconds)
curr_spell_dmg = curr_spell_dmg + eligible_dmg[new_spell]
eligible_pow.pop(new_spell)
eligible_dmg.pop(new_spell)
if (curr_spell_dmg <= reg_rate) and (len(eligible_pow) == 0):
print("NO")
break
else:
new_max_pow = new_max_pow - curr_spell_dmg + reg_rate
if new_max_pow > max_pow:
new_max_pow = max_pow
seconds = seconds + 1
if (new_max_pow<=0):
print("YES")
print(seconds,spell_used)
for i in range(len(list_of_spell_used)):
spell_num.append(input_spell.index(list_of_spell_used[i]))
input_spell[spell_num[i]]="None"
for i in range(len(spell_num)):
print( spell_used_time[i],spell_num[i]+1)
``` | output | 1 | 41,554 | 2 | 83,109 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya’s elder brother Petya loves playing computer games. In one of his favourite computer games Petya reached the final level where a fight with the boss take place.
While playing the game Petya found spell scrolls and now he is about to use them. Let’s describe the way fighting goes on this level:
1) The boss has two parameters: max — the initial amount of health and reg — regeneration rate per second.
2) Every scroll also has two parameters: powi — spell power measured in percents — the maximal amount of health counted off the initial one, which allows to use the scroll (i.e. if the boss has more than powi percent of health the scroll cannot be used); and dmgi the damage per second inflicted upon the boss if the scroll is used. As soon as a scroll is used it disappears and another spell is cast upon the boss that inflicts dmgi of damage per second upon him until the end of the game.
During the battle the actions per second are performed in the following order: first the boss gets the damage from all the spells cast upon him, then he regenerates reg of health (at the same time he can’t have more than max of health), then the player may use another scroll (no more than one per second).
The boss is considered to be defeated if at the end of a second he has nonpositive ( ≤ 0) amount of health.
Help Petya to determine whether he can win with the set of scrolls available to him and if he can, determine the minimal number of seconds he needs to do it.
Input
The first line contains three integers N, max and reg (1 ≤ N, max, reg ≤ 1000) –– the amount of scrolls and the parameters of the boss. The next N lines contain two integers powi and dmgi each — the parameters of the i-th scroll (0 ≤ powi ≤ 100, 1 ≤ dmgi ≤ 2000).
Output
In case Petya can’t complete this level, output in the single line NO.
Otherwise, output on the first line YES. On the second line output the minimal time after which the boss can be defeated and the number of used scrolls. In the next lines for each used scroll output space-separated number of seconds passed from the start of the battle to the moment the scroll was used and the number of the scroll. Scrolls are numbered starting from 1 in the input order. The first scroll is considered to be available to be used after 0 seconds.
Output scrolls in the order they were used. It is not allowed to use scrolls after the boss is defeated.
Examples
Input
2 10 3
100 3
99 1
Output
NO
Input
2 100 10
100 11
90 9
Output
YES
19 2
0 1
10 2 | instruction | 0 | 41,555 | 2 | 83,110 |
Tags: greedy, implementation
Correct Solution:
```
class Scroll:
def __init__(self, id, power, damage):
self.id = id
self.power = power
self.damage = damage
self.active = False
num_scrolls, boss_max, regenerate = map(int, input().split())
scrolls = [Scroll(i+1, *map(int, input().split())) for i in range(num_scrolls)]
scrolls.sort(key = lambda scroll: -scroll.damage)
boss_curr = boss_max
scroll_damage = 0
active_scrolls = []
tick = 0
while True:
boss_prev = boss_curr
boss_curr -= scroll_damage
boss_curr = min(boss_max, boss_curr + regenerate)
if boss_curr <= 0:
print('YES')
print(tick, len(active_scrolls))
for scroll in active_scrolls:
print(scroll.start, scroll.id)
break
found = False
for scroll in scrolls:
if not scroll.active and 100*boss_curr <= scroll.power*boss_max:
scroll.start = tick
scroll.active = True
active_scrolls.append(scroll)
scroll_damage += scroll.damage
found = True
break
if not found and boss_curr >= boss_prev:
print('NO')
break
tick += 1
``` | output | 1 | 41,555 | 2 | 83,111 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya’s elder brother Petya loves playing computer games. In one of his favourite computer games Petya reached the final level where a fight with the boss take place.
While playing the game Petya found spell scrolls and now he is about to use them. Let’s describe the way fighting goes on this level:
1) The boss has two parameters: max — the initial amount of health and reg — regeneration rate per second.
2) Every scroll also has two parameters: powi — spell power measured in percents — the maximal amount of health counted off the initial one, which allows to use the scroll (i.e. if the boss has more than powi percent of health the scroll cannot be used); and dmgi the damage per second inflicted upon the boss if the scroll is used. As soon as a scroll is used it disappears and another spell is cast upon the boss that inflicts dmgi of damage per second upon him until the end of the game.
During the battle the actions per second are performed in the following order: first the boss gets the damage from all the spells cast upon him, then he regenerates reg of health (at the same time he can’t have more than max of health), then the player may use another scroll (no more than one per second).
The boss is considered to be defeated if at the end of a second he has nonpositive ( ≤ 0) amount of health.
Help Petya to determine whether he can win with the set of scrolls available to him and if he can, determine the minimal number of seconds he needs to do it.
Input
The first line contains three integers N, max and reg (1 ≤ N, max, reg ≤ 1000) –– the amount of scrolls and the parameters of the boss. The next N lines contain two integers powi and dmgi each — the parameters of the i-th scroll (0 ≤ powi ≤ 100, 1 ≤ dmgi ≤ 2000).
Output
In case Petya can’t complete this level, output in the single line NO.
Otherwise, output on the first line YES. On the second line output the minimal time after which the boss can be defeated and the number of used scrolls. In the next lines for each used scroll output space-separated number of seconds passed from the start of the battle to the moment the scroll was used and the number of the scroll. Scrolls are numbered starting from 1 in the input order. The first scroll is considered to be available to be used after 0 seconds.
Output scrolls in the order they were used. It is not allowed to use scrolls after the boss is defeated.
Examples
Input
2 10 3
100 3
99 1
Output
NO
Input
2 100 10
100 11
90 9
Output
YES
19 2
0 1
10 2 | instruction | 0 | 41,556 | 2 | 83,112 |
Tags: greedy, implementation
Correct Solution:
```
import itertools
import math
N, x, y = [int(n) for n in input().split()]
pills = []
for i in range(N):
pills.append(tuple(int(n) for n in input().split()) + (i+1,))
pills.sort()
rques = x
qauto = 0
time = 0
used = []
possible = set()
while rques > 0:
while len(pills) > 0 and pills[-1][0] >= 100*rques/x:
possible.add(pills.pop()[1:])
if len(possible) > 0:
best = max(possible)
used.append((best, time))
possible.remove(best)
qauto += best[0]
elif qauto <= y:
print('NO')
break
rques = min(rques+y-qauto, x)
time += 1
else:
print('YES')
print(time, len(used))
for scroll in used:
print(scroll[1], scroll[0][1])
``` | output | 1 | 41,556 | 2 | 83,113 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya’s elder brother Petya loves playing computer games. In one of his favourite computer games Petya reached the final level where a fight with the boss take place.
While playing the game Petya found spell scrolls and now he is about to use them. Let’s describe the way fighting goes on this level:
1) The boss has two parameters: max — the initial amount of health and reg — regeneration rate per second.
2) Every scroll also has two parameters: powi — spell power measured in percents — the maximal amount of health counted off the initial one, which allows to use the scroll (i.e. if the boss has more than powi percent of health the scroll cannot be used); and dmgi the damage per second inflicted upon the boss if the scroll is used. As soon as a scroll is used it disappears and another spell is cast upon the boss that inflicts dmgi of damage per second upon him until the end of the game.
During the battle the actions per second are performed in the following order: first the boss gets the damage from all the spells cast upon him, then he regenerates reg of health (at the same time he can’t have more than max of health), then the player may use another scroll (no more than one per second).
The boss is considered to be defeated if at the end of a second he has nonpositive ( ≤ 0) amount of health.
Help Petya to determine whether he can win with the set of scrolls available to him and if he can, determine the minimal number of seconds he needs to do it.
Input
The first line contains three integers N, max and reg (1 ≤ N, max, reg ≤ 1000) –– the amount of scrolls and the parameters of the boss. The next N lines contain two integers powi and dmgi each — the parameters of the i-th scroll (0 ≤ powi ≤ 100, 1 ≤ dmgi ≤ 2000).
Output
In case Petya can’t complete this level, output in the single line NO.
Otherwise, output on the first line YES. On the second line output the minimal time after which the boss can be defeated and the number of used scrolls. In the next lines for each used scroll output space-separated number of seconds passed from the start of the battle to the moment the scroll was used and the number of the scroll. Scrolls are numbered starting from 1 in the input order. The first scroll is considered to be available to be used after 0 seconds.
Output scrolls in the order they were used. It is not allowed to use scrolls after the boss is defeated.
Examples
Input
2 10 3
100 3
99 1
Output
NO
Input
2 100 10
100 11
90 9
Output
YES
19 2
0 1
10 2 | instruction | 0 | 41,557 | 2 | 83,114 |
Tags: greedy, implementation
Correct Solution:
```
import itertools
import math
N, maxhealth, reg = [int(x) for x in input().split()]
scrolls = []
for i in range(N):
scrolls.append(tuple(int(x) for x in input().split()) + (i+1,))
scrolls.sort()
health = maxhealth
dmg = 0
timer = 0
used = []
possible = set()
while health > 0:
while len(scrolls) > 0 and scrolls[-1][0] >= 100*health/maxhealth:
possible.add(scrolls.pop()[1:])
if len(possible) > 0:
best = max(possible)
used.append((best, timer))
possible.remove(best)
dmg += best[0]
elif dmg <= reg:
print('NO')
break
health = min(health+reg-dmg, maxhealth)
timer += 1
else:
print('YES')
print(timer, len(used))
for scroll in used:
print(scroll[1], scroll[0][1])
``` | output | 1 | 41,557 | 2 | 83,115 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya’s elder brother Petya loves playing computer games. In one of his favourite computer games Petya reached the final level where a fight with the boss take place.
While playing the game Petya found spell scrolls and now he is about to use them. Let’s describe the way fighting goes on this level:
1) The boss has two parameters: max — the initial amount of health and reg — regeneration rate per second.
2) Every scroll also has two parameters: powi — spell power measured in percents — the maximal amount of health counted off the initial one, which allows to use the scroll (i.e. if the boss has more than powi percent of health the scroll cannot be used); and dmgi the damage per second inflicted upon the boss if the scroll is used. As soon as a scroll is used it disappears and another spell is cast upon the boss that inflicts dmgi of damage per second upon him until the end of the game.
During the battle the actions per second are performed in the following order: first the boss gets the damage from all the spells cast upon him, then he regenerates reg of health (at the same time he can’t have more than max of health), then the player may use another scroll (no more than one per second).
The boss is considered to be defeated if at the end of a second he has nonpositive ( ≤ 0) amount of health.
Help Petya to determine whether he can win with the set of scrolls available to him and if he can, determine the minimal number of seconds he needs to do it.
Input
The first line contains three integers N, max and reg (1 ≤ N, max, reg ≤ 1000) –– the amount of scrolls and the parameters of the boss. The next N lines contain two integers powi and dmgi each — the parameters of the i-th scroll (0 ≤ powi ≤ 100, 1 ≤ dmgi ≤ 2000).
Output
In case Petya can’t complete this level, output in the single line NO.
Otherwise, output on the first line YES. On the second line output the minimal time after which the boss can be defeated and the number of used scrolls. In the next lines for each used scroll output space-separated number of seconds passed from the start of the battle to the moment the scroll was used and the number of the scroll. Scrolls are numbered starting from 1 in the input order. The first scroll is considered to be available to be used after 0 seconds.
Output scrolls in the order they were used. It is not allowed to use scrolls after the boss is defeated.
Examples
Input
2 10 3
100 3
99 1
Output
NO
Input
2 100 10
100 11
90 9
Output
YES
19 2
0 1
10 2
Submitted Solution:
```
spell_used = 0
parameters = input().split()
num_spell = int(parameters[0])
max_pow = int(parameters[1])
reg_rate = int(parameters[2])
input_spell = [0 for i in range(num_spell)]
spell = [0 for i in range(num_spell)]
power = [0 for i in range(num_spell)]
dmg = [0 for i in range(num_spell)]
for i in range(num_spell):
input_spell[i]=input()
spell[i]= input_spell[i].split()
for i in range(num_spell):
power[i]= int(spell[i][0])
dmg[i] = int(spell[i][1])
seconds = 0
new_spell = 0
curr_spell_dmg = 0
new_max_pow = max_pow
eligible_pow = []
eligible_dmg = []
ind=[]
spell_num=[]
list_of_spell_used=[]
spell_used_time = []
while (new_max_pow>0):
for i in range(len(power)):
if power[i]*max_pow >= new_max_pow*100:
eligible_pow.append(power[i])
eligible_dmg.append(dmg[i])
ind.append(i)
power = [i for j, i in enumerate(power) if j not in ind]
dmg = [i for j, i in enumerate(dmg) if j not in ind]
ind = []
if len(eligible_pow) != 0:
new_spell = eligible_dmg.index(max(eligible_dmg))
spell_used = spell_used + 1
list_of_spell_used.append(str(eligible_pow[new_spell])+" "+str(eligible_dmg[new_spell]))
spell_used_time.append(seconds)
curr_spell_dmg = curr_spell_dmg + eligible_dmg[new_spell]
eligible_pow.pop(new_spell)
eligible_dmg.pop(new_spell)
if (curr_spell_dmg <= reg_rate) and (len(eligible_pow) == 0):
print("NO")
break
else:
new_max_pow = new_max_pow - curr_spell_dmg + reg_rate
if new_max_pow > max_pow:
new_max_pow = max_pow
seconds = seconds + 1
if (new_max_pow<=0):
print("YES")
print(seconds,spell_used)
for i in range(len(list_of_spell_used)):
spell_num.append(input_spell.index(list_of_spell_used[i]))
for i in range(len(spell_num)):
print( spell_used_time[i],spell_num[i]+1)
``` | instruction | 0 | 41,558 | 2 | 83,116 |
No | output | 1 | 41,558 | 2 | 83,117 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya’s elder brother Petya loves playing computer games. In one of his favourite computer games Petya reached the final level where a fight with the boss take place.
While playing the game Petya found spell scrolls and now he is about to use them. Let’s describe the way fighting goes on this level:
1) The boss has two parameters: max — the initial amount of health and reg — regeneration rate per second.
2) Every scroll also has two parameters: powi — spell power measured in percents — the maximal amount of health counted off the initial one, which allows to use the scroll (i.e. if the boss has more than powi percent of health the scroll cannot be used); and dmgi the damage per second inflicted upon the boss if the scroll is used. As soon as a scroll is used it disappears and another spell is cast upon the boss that inflicts dmgi of damage per second upon him until the end of the game.
During the battle the actions per second are performed in the following order: first the boss gets the damage from all the spells cast upon him, then he regenerates reg of health (at the same time he can’t have more than max of health), then the player may use another scroll (no more than one per second).
The boss is considered to be defeated if at the end of a second he has nonpositive ( ≤ 0) amount of health.
Help Petya to determine whether he can win with the set of scrolls available to him and if he can, determine the minimal number of seconds he needs to do it.
Input
The first line contains three integers N, max and reg (1 ≤ N, max, reg ≤ 1000) –– the amount of scrolls and the parameters of the boss. The next N lines contain two integers powi and dmgi each — the parameters of the i-th scroll (0 ≤ powi ≤ 100, 1 ≤ dmgi ≤ 2000).
Output
In case Petya can’t complete this level, output in the single line NO.
Otherwise, output on the first line YES. On the second line output the minimal time after which the boss can be defeated and the number of used scrolls. In the next lines for each used scroll output space-separated number of seconds passed from the start of the battle to the moment the scroll was used and the number of the scroll. Scrolls are numbered starting from 1 in the input order. The first scroll is considered to be available to be used after 0 seconds.
Output scrolls in the order they were used. It is not allowed to use scrolls after the boss is defeated.
Examples
Input
2 10 3
100 3
99 1
Output
NO
Input
2 100 10
100 11
90 9
Output
YES
19 2
0 1
10 2
Submitted Solution:
```
class Scroll:
def __init__(self, id, power, damage):
self.id = id
self.power = power
self.damage = damage
self.start = 10000
num_scrolls, boss_max, regenerate = map(int, input().split())
scrolls = [Scroll(i+1, *map(int, input().split())) for i in range(num_scrolls)]
scrolls.sort(key = lambda scroll: scroll.damage)
boss_curr = boss_max
active = set()
tick = 0
while True:
boss_prev = boss_curr
for ix in active:
boss_curr -= scrolls[ix].damage
boss_curr = min(boss_max, boss_curr + regenerate)
if boss_curr <= 0:
print('YES')
print(tick, len(active))
scrolls.sort(key = lambda scroll: scroll.start)
for ix, scroll in enumerate(scrolls):
if ix in active:
print(scroll.start, scroll.id)
break
found = False
for ix, scroll in enumerate(scrolls):
if ix not in active and 100*boss_curr <= scroll.power*boss_max:
scroll.start = tick
active.add(ix)
found = True
break
if not found and boss_curr >= boss_prev:
print('NO')
break
tick += 1
``` | instruction | 0 | 41,559 | 2 | 83,118 |
No | output | 1 | 41,559 | 2 | 83,119 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya’s elder brother Petya loves playing computer games. In one of his favourite computer games Petya reached the final level where a fight with the boss take place.
While playing the game Petya found spell scrolls and now he is about to use them. Let’s describe the way fighting goes on this level:
1) The boss has two parameters: max — the initial amount of health and reg — regeneration rate per second.
2) Every scroll also has two parameters: powi — spell power measured in percents — the maximal amount of health counted off the initial one, which allows to use the scroll (i.e. if the boss has more than powi percent of health the scroll cannot be used); and dmgi the damage per second inflicted upon the boss if the scroll is used. As soon as a scroll is used it disappears and another spell is cast upon the boss that inflicts dmgi of damage per second upon him until the end of the game.
During the battle the actions per second are performed in the following order: first the boss gets the damage from all the spells cast upon him, then he regenerates reg of health (at the same time he can’t have more than max of health), then the player may use another scroll (no more than one per second).
The boss is considered to be defeated if at the end of a second he has nonpositive ( ≤ 0) amount of health.
Help Petya to determine whether he can win with the set of scrolls available to him and if he can, determine the minimal number of seconds he needs to do it.
Input
The first line contains three integers N, max and reg (1 ≤ N, max, reg ≤ 1000) –– the amount of scrolls and the parameters of the boss. The next N lines contain two integers powi and dmgi each — the parameters of the i-th scroll (0 ≤ powi ≤ 100, 1 ≤ dmgi ≤ 2000).
Output
In case Petya can’t complete this level, output in the single line NO.
Otherwise, output on the first line YES. On the second line output the minimal time after which the boss can be defeated and the number of used scrolls. In the next lines for each used scroll output space-separated number of seconds passed from the start of the battle to the moment the scroll was used and the number of the scroll. Scrolls are numbered starting from 1 in the input order. The first scroll is considered to be available to be used after 0 seconds.
Output scrolls in the order they were used. It is not allowed to use scrolls after the boss is defeated.
Examples
Input
2 10 3
100 3
99 1
Output
NO
Input
2 100 10
100 11
90 9
Output
YES
19 2
0 1
10 2
Submitted Solution:
```
spell_used = 0
parameters = input().split()
num_spell = int(parameters[0])
max_pow = int(parameters[1])
reg_rate = int(parameters[2])
input_spell = [0 for i in range(num_spell)]
spell = [0 for i in range(num_spell)]
power = [0 for i in range(num_spell)]
dmg = [0 for i in range(num_spell)]
for i in range(num_spell):
input_spell[i]=input()
spell[i]= input_spell[i].split()
for i in range(num_spell):
power[i]= int(spell[i][0])
dmg[i] = int(spell[i][1])
seconds = 1
new_spell = 0
curr_spell_dmg = 0
# for i in range(num_spell):
# power[i] = int(input("Power"))
# dmg[i] = int(input("damage"))
# num_spell = 2
# max_pow = 10
new_max_pow = max_pow
# reg_rate = 2
# power = [10,9]
# dmg = [3,9]
eligible_pow = []
eligible_dmg = []
ind=[]
spell_num=[]
list_of_spell_used=[]
spell_used_time = []
while (new_max_pow>0):
for i in range(len(power)):
if power[i] >= new_max_pow:
eligible_pow.append(power[i])
eligible_dmg.append(dmg[i])
ind.append(i)
power = [i for j, i in enumerate(power) if j not in ind]
dmg = [i for j, i in enumerate(dmg) if j not in ind]
ind = []
if len(eligible_pow) != 0:
new_spell = eligible_dmg.index(max(eligible_dmg))
spell_used = spell_used + 1
list_of_spell_used.append(str(eligible_pow[new_spell])+" "+str(eligible_dmg[new_spell]))
spell_used_time.append(seconds)
curr_spell_dmg = curr_spell_dmg + eligible_dmg[new_spell]
eligible_pow.pop(new_spell)
eligible_dmg.pop(new_spell)
if (curr_spell_dmg <= reg_rate) and (len(eligible_pow) == 0):
print("NO")
break
else:
new_max_pow = new_max_pow - curr_spell_dmg + reg_rate
if new_max_pow > max_pow:
new_max_pow = max_pow
seconds = seconds + 1
if (new_max_pow<=0):
print("Yes")
print(seconds,spell_used)
for i in range(len(list_of_spell_used)):
spell_num.append(input_spell.index(list_of_spell_used[i]))
for i in range(len(spell_num)):
print(spell_num[i], spell_used_time[i])
``` | instruction | 0 | 41,560 | 2 | 83,120 |
No | output | 1 | 41,560 | 2 | 83,121 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya’s elder brother Petya loves playing computer games. In one of his favourite computer games Petya reached the final level where a fight with the boss take place.
While playing the game Petya found spell scrolls and now he is about to use them. Let’s describe the way fighting goes on this level:
1) The boss has two parameters: max — the initial amount of health and reg — regeneration rate per second.
2) Every scroll also has two parameters: powi — spell power measured in percents — the maximal amount of health counted off the initial one, which allows to use the scroll (i.e. if the boss has more than powi percent of health the scroll cannot be used); and dmgi the damage per second inflicted upon the boss if the scroll is used. As soon as a scroll is used it disappears and another spell is cast upon the boss that inflicts dmgi of damage per second upon him until the end of the game.
During the battle the actions per second are performed in the following order: first the boss gets the damage from all the spells cast upon him, then he regenerates reg of health (at the same time he can’t have more than max of health), then the player may use another scroll (no more than one per second).
The boss is considered to be defeated if at the end of a second he has nonpositive ( ≤ 0) amount of health.
Help Petya to determine whether he can win with the set of scrolls available to him and if he can, determine the minimal number of seconds he needs to do it.
Input
The first line contains three integers N, max and reg (1 ≤ N, max, reg ≤ 1000) –– the amount of scrolls and the parameters of the boss. The next N lines contain two integers powi and dmgi each — the parameters of the i-th scroll (0 ≤ powi ≤ 100, 1 ≤ dmgi ≤ 2000).
Output
In case Petya can’t complete this level, output in the single line NO.
Otherwise, output on the first line YES. On the second line output the minimal time after which the boss can be defeated and the number of used scrolls. In the next lines for each used scroll output space-separated number of seconds passed from the start of the battle to the moment the scroll was used and the number of the scroll. Scrolls are numbered starting from 1 in the input order. The first scroll is considered to be available to be used after 0 seconds.
Output scrolls in the order they were used. It is not allowed to use scrolls after the boss is defeated.
Examples
Input
2 10 3
100 3
99 1
Output
NO
Input
2 100 10
100 11
90 9
Output
YES
19 2
0 1
10 2
Submitted Solution:
```
spell_used = 0
parameters = input().split()
num_spell = int(parameters[0])
max_pow = int(parameters[1])
reg_rate = int(parameters[2])
input_spell = [0 for i in range(num_spell)]
spell = [0 for i in range(num_spell)]
power = [0 for i in range(num_spell)]
dmg = [0 for i in range(num_spell)]
for i in range(num_spell):
input_spell[i]=input()
spell[i]= input_spell[i].split()
for i in range(num_spell):
power[i]= int(spell[i][0])
dmg[i] = int(spell[i][1])
seconds = 0
new_spell = 0
curr_spell_dmg = 0
new_max_pow = max_pow
eligible_pow = []
eligible_dmg = []
ind=[]
spell_num=[]
list_of_spell_used=[]
spell_used_time = []
while (new_max_pow>0):
for i in range(len(power)):
if power[i]*max_pow >= new_max_pow*100:
eligible_pow.append(power[i])
eligible_dmg.append(dmg[i])
ind.append(i)
power = [i for j, i in enumerate(power) if j not in ind]
dmg = [i for j, i in enumerate(dmg) if j not in ind]
ind = []
if len(eligible_pow) != 0:
new_spell = eligible_dmg.index(max(eligible_dmg))
spell_used = spell_used + 1
list_of_spell_used.append(str(eligible_pow[new_spell])+" "+str(eligible_dmg[new_spell]))
spell_used_time.append(seconds)
curr_spell_dmg = curr_spell_dmg + eligible_dmg[new_spell]
eligible_pow.pop(new_spell)
eligible_dmg.pop(new_spell)
if (curr_spell_dmg <= reg_rate) and (len(eligible_pow) == 0):
print("NO")
break
else:
new_max_pow = new_max_pow - curr_spell_dmg + reg_rate
if new_max_pow > max_pow:
new_max_pow = max_pow
seconds = seconds + 1
if (new_max_pow<=0):
print("Yes")
print(seconds,spell_used)
for i in range(len(list_of_spell_used)):
spell_num.append(input_spell.index(list_of_spell_used[i]))
for i in range(len(spell_num)):
print( spell_used_time[i],spell_num[i]+1)
``` | instruction | 0 | 41,561 | 2 | 83,122 |
No | output | 1 | 41,561 | 2 | 83,123 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vlad is fond of popular computer game Bota-2. Recently, the developers announced the new add-on named Bota-3. Of course, Vlad immediately bought only to find out his computer is too old for the new game and needs to be updated.
There are n video cards in the shop, the power of the i-th video card is equal to integer value ai. As Vlad wants to be sure the new game will work he wants to buy not one, but several video cards and unite their powers using the cutting-edge technology. To use this technology one of the cards is chosen as the leading one and other video cards are attached to it as secondary. For this new technology to work it's required that the power of each of the secondary video cards is divisible by the power of the leading video card. In order to achieve that the power of any secondary video card can be reduced to any integer value less or equal than the current power. However, the power of the leading video card should remain unchanged, i.e. it can't be reduced.
Vlad has an infinite amount of money so he can buy any set of video cards. Help him determine which video cards he should buy such that after picking the leading video card and may be reducing some powers of others to make them work together he will get the maximum total value of video power.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of video cards in the shop.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 200 000) — powers of video cards.
Output
The only line of the output should contain one integer value — the maximum possible total power of video cards working together.
Examples
Input
4
3 2 15 9
Output
27
Input
4
8 2 2 7
Output
18
Note
In the first sample, it would be optimal to buy video cards with powers 3, 15 and 9. The video card with power 3 should be chosen as the leading one and all other video cards will be compatible with it. Thus, the total power would be 3 + 15 + 9 = 27. If he buys all the video cards and pick the one with the power 2 as the leading, the powers of all other video cards should be reduced by 1, thus the total power would be 2 + 2 + 14 + 8 = 26, that is less than 27. Please note, that it's not allowed to reduce the power of the leading video card, i.e. one can't get the total power 3 + 1 + 15 + 9 = 28.
In the second sample, the optimal answer is to buy all video cards and pick the one with the power 2 as the leading. The video card with the power 7 needs it power to be reduced down to 6. The total power would be 8 + 2 + 2 + 6 = 18.
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
l1=[0]*200001
for i in l:
l1[i]+=1
for i in range(1,200001):
l1[i]+=l1[i-1]
m=0
l=list(set(l))
for i in l:
s=0
for j in range(i,200001,i):
s+=(l1[min(200000,i+j-1)]-l1[j-1])*j
if(s>m):
m=s
print(m)
``` | instruction | 0 | 41,698 | 2 | 83,396 |
Yes | output | 1 | 41,698 | 2 | 83,397 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vlad is fond of popular computer game Bota-2. Recently, the developers announced the new add-on named Bota-3. Of course, Vlad immediately bought only to find out his computer is too old for the new game and needs to be updated.
There are n video cards in the shop, the power of the i-th video card is equal to integer value ai. As Vlad wants to be sure the new game will work he wants to buy not one, but several video cards and unite their powers using the cutting-edge technology. To use this technology one of the cards is chosen as the leading one and other video cards are attached to it as secondary. For this new technology to work it's required that the power of each of the secondary video cards is divisible by the power of the leading video card. In order to achieve that the power of any secondary video card can be reduced to any integer value less or equal than the current power. However, the power of the leading video card should remain unchanged, i.e. it can't be reduced.
Vlad has an infinite amount of money so he can buy any set of video cards. Help him determine which video cards he should buy such that after picking the leading video card and may be reducing some powers of others to make them work together he will get the maximum total value of video power.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of video cards in the shop.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 200 000) — powers of video cards.
Output
The only line of the output should contain one integer value — the maximum possible total power of video cards working together.
Examples
Input
4
3 2 15 9
Output
27
Input
4
8 2 2 7
Output
18
Note
In the first sample, it would be optimal to buy video cards with powers 3, 15 and 9. The video card with power 3 should be chosen as the leading one and all other video cards will be compatible with it. Thus, the total power would be 3 + 15 + 9 = 27. If he buys all the video cards and pick the one with the power 2 as the leading, the powers of all other video cards should be reduced by 1, thus the total power would be 2 + 2 + 14 + 8 = 26, that is less than 27. Please note, that it's not allowed to reduce the power of the leading video card, i.e. one can't get the total power 3 + 1 + 15 + 9 = 28.
In the second sample, the optimal answer is to buy all video cards and pick the one with the power 2 as the leading. The video card with the power 7 needs it power to be reduced down to 6. The total power would be 8 + 2 + 2 + 6 = 18.
Submitted Solution:
```
import math
prefSum = []
def GetSum( l, r ):
return prefSum[min( r, 199999 )] - prefSum[l - 1]
# cin = open( "input.txt", 'r' )
# n = int( cin.readline() )
# a = list( map( int, cin.read().split() ) )
# cnt = 0;
# for i in range( 1, 200000 ):
# cnt += 200000 / i
# print( cnt )
# exit( 0 )
n = int( input() )
a = list( map( int, input().split() ) )
b = []
for i in range( 2 * ( 10 ** 5 ) + 10 ):
b.append( 0 )
for i in range( n ):
b[a[i]] += 1
prefSum.append( 0 )
for i in range( 1, 2 * ( 10 ** 5 ) + 10 ):
prefSum.append( b[i] + prefSum[i - 1] )
ans = 0
cnt = 0
for i in range( 2 * ( 10 ** 5 ) + 10 ):
if b[i] == 0:
continue
l = i
r = 2 * i - 1
curAns = 0;
for l in range( i, 200001, i ):
curAns += l * ( prefSum[min( r, 200000 )] - prefSum[l - 1] )
r += i
ans = max( ans, curAns )
print( ans )
``` | instruction | 0 | 41,699 | 2 | 83,398 |
Yes | output | 1 | 41,699 | 2 | 83,399 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vlad is fond of popular computer game Bota-2. Recently, the developers announced the new add-on named Bota-3. Of course, Vlad immediately bought only to find out his computer is too old for the new game and needs to be updated.
There are n video cards in the shop, the power of the i-th video card is equal to integer value ai. As Vlad wants to be sure the new game will work he wants to buy not one, but several video cards and unite their powers using the cutting-edge technology. To use this technology one of the cards is chosen as the leading one and other video cards are attached to it as secondary. For this new technology to work it's required that the power of each of the secondary video cards is divisible by the power of the leading video card. In order to achieve that the power of any secondary video card can be reduced to any integer value less or equal than the current power. However, the power of the leading video card should remain unchanged, i.e. it can't be reduced.
Vlad has an infinite amount of money so he can buy any set of video cards. Help him determine which video cards he should buy such that after picking the leading video card and may be reducing some powers of others to make them work together he will get the maximum total value of video power.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of video cards in the shop.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 200 000) — powers of video cards.
Output
The only line of the output should contain one integer value — the maximum possible total power of video cards working together.
Examples
Input
4
3 2 15 9
Output
27
Input
4
8 2 2 7
Output
18
Note
In the first sample, it would be optimal to buy video cards with powers 3, 15 and 9. The video card with power 3 should be chosen as the leading one and all other video cards will be compatible with it. Thus, the total power would be 3 + 15 + 9 = 27. If he buys all the video cards and pick the one with the power 2 as the leading, the powers of all other video cards should be reduced by 1, thus the total power would be 2 + 2 + 14 + 8 = 26, that is less than 27. Please note, that it's not allowed to reduce the power of the leading video card, i.e. one can't get the total power 3 + 1 + 15 + 9 = 28.
In the second sample, the optimal answer is to buy all video cards and pick the one with the power 2 as the leading. The video card with the power 7 needs it power to be reduced down to 6. The total power would be 8 + 2 + 2 + 6 = 18.
Submitted Solution:
```
def solve():
n=int(input())
v=list(map(int,input().split()))
v.sort()
prev=-1
result=-1
for i in range(n):
if v[i]==prev:
continue;
prev=v[i]
test=sum([v[j]//v[i]*v[i] for j in range(i,n)])
if test<result:
break
result=test
print(result)
solve()
``` | instruction | 0 | 41,700 | 2 | 83,400 |
No | output | 1 | 41,700 | 2 | 83,401 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vlad is fond of popular computer game Bota-2. Recently, the developers announced the new add-on named Bota-3. Of course, Vlad immediately bought only to find out his computer is too old for the new game and needs to be updated.
There are n video cards in the shop, the power of the i-th video card is equal to integer value ai. As Vlad wants to be sure the new game will work he wants to buy not one, but several video cards and unite their powers using the cutting-edge technology. To use this technology one of the cards is chosen as the leading one and other video cards are attached to it as secondary. For this new technology to work it's required that the power of each of the secondary video cards is divisible by the power of the leading video card. In order to achieve that the power of any secondary video card can be reduced to any integer value less or equal than the current power. However, the power of the leading video card should remain unchanged, i.e. it can't be reduced.
Vlad has an infinite amount of money so he can buy any set of video cards. Help him determine which video cards he should buy such that after picking the leading video card and may be reducing some powers of others to make them work together he will get the maximum total value of video power.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of video cards in the shop.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 200 000) — powers of video cards.
Output
The only line of the output should contain one integer value — the maximum possible total power of video cards working together.
Examples
Input
4
3 2 15 9
Output
27
Input
4
8 2 2 7
Output
18
Note
In the first sample, it would be optimal to buy video cards with powers 3, 15 and 9. The video card with power 3 should be chosen as the leading one and all other video cards will be compatible with it. Thus, the total power would be 3 + 15 + 9 = 27. If he buys all the video cards and pick the one with the power 2 as the leading, the powers of all other video cards should be reduced by 1, thus the total power would be 2 + 2 + 14 + 8 = 26, that is less than 27. Please note, that it's not allowed to reduce the power of the leading video card, i.e. one can't get the total power 3 + 1 + 15 + 9 = 28.
In the second sample, the optimal answer is to buy all video cards and pick the one with the power 2 as the leading. The video card with the power 7 needs it power to be reduced down to 6. The total power would be 8 + 2 + 2 + 6 = 18.
Submitted Solution:
```
def O6():
n = [int(x) for x in input() if 1<= int(x) <= 2e5][0]
cards = sorted([int(x) for x in input().split() if 1 <= int(x) <= 2e5])
total =0
for i in range(len(cards)):
primary = cards[i]
if primary > 10:
break
sec_cards = [x for x in cards]
sec_cards.remove(primary)
for i in range(len(sec_cards)):
if (sec_cards[i] < primary):
sec_cards[i] = 0
break
while( sec_cards[i] % primary != 0):
sec_cards[i]-=1
newtotal = sum(sec_cards) + primary
if newtotal > total:
total = newtotal
print(total)
if __name__ == '__main__':
O6()
``` | instruction | 0 | 41,701 | 2 | 83,402 |
No | output | 1 | 41,701 | 2 | 83,403 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vlad is fond of popular computer game Bota-2. Recently, the developers announced the new add-on named Bota-3. Of course, Vlad immediately bought only to find out his computer is too old for the new game and needs to be updated.
There are n video cards in the shop, the power of the i-th video card is equal to integer value ai. As Vlad wants to be sure the new game will work he wants to buy not one, but several video cards and unite their powers using the cutting-edge technology. To use this technology one of the cards is chosen as the leading one and other video cards are attached to it as secondary. For this new technology to work it's required that the power of each of the secondary video cards is divisible by the power of the leading video card. In order to achieve that the power of any secondary video card can be reduced to any integer value less or equal than the current power. However, the power of the leading video card should remain unchanged, i.e. it can't be reduced.
Vlad has an infinite amount of money so he can buy any set of video cards. Help him determine which video cards he should buy such that after picking the leading video card and may be reducing some powers of others to make them work together he will get the maximum total value of video power.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of video cards in the shop.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 200 000) — powers of video cards.
Output
The only line of the output should contain one integer value — the maximum possible total power of video cards working together.
Examples
Input
4
3 2 15 9
Output
27
Input
4
8 2 2 7
Output
18
Note
In the first sample, it would be optimal to buy video cards with powers 3, 15 and 9. The video card with power 3 should be chosen as the leading one and all other video cards will be compatible with it. Thus, the total power would be 3 + 15 + 9 = 27. If he buys all the video cards and pick the one with the power 2 as the leading, the powers of all other video cards should be reduced by 1, thus the total power would be 2 + 2 + 14 + 8 = 26, that is less than 27. Please note, that it's not allowed to reduce the power of the leading video card, i.e. one can't get the total power 3 + 1 + 15 + 9 = 28.
In the second sample, the optimal answer is to buy all video cards and pick the one with the power 2 as the leading. The video card with the power 7 needs it power to be reduced down to 6. The total power would be 8 + 2 + 2 + 6 = 18.
Submitted Solution:
```
import re
import time
numCards = int(input())
if numCards > 30000:
print("wrong")
else:
prime = []
cardPowers = [int(x) for x in re.split("\\s", input())]
startTime = time.time()
cardPowers.sort()
prime.append(cardPowers[0])
for x in range(1, numCards):
z = cardPowers[x]
newPrime = True
y = 0
while newPrime and y < len(prime):
if z%prime[y]==0:
newPrime = False
y += 1
if newPrime:
prime.append(z)
setList = []
count = 0
for x in prime:
setList.append(0)
for y in cardPowers:
setList[count] += y - (y%x)
count += 1
setList.sort()
print(setList[-1])
``` | instruction | 0 | 41,702 | 2 | 83,404 |
No | output | 1 | 41,702 | 2 | 83,405 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vlad is fond of popular computer game Bota-2. Recently, the developers announced the new add-on named Bota-3. Of course, Vlad immediately bought only to find out his computer is too old for the new game and needs to be updated.
There are n video cards in the shop, the power of the i-th video card is equal to integer value ai. As Vlad wants to be sure the new game will work he wants to buy not one, but several video cards and unite their powers using the cutting-edge technology. To use this technology one of the cards is chosen as the leading one and other video cards are attached to it as secondary. For this new technology to work it's required that the power of each of the secondary video cards is divisible by the power of the leading video card. In order to achieve that the power of any secondary video card can be reduced to any integer value less or equal than the current power. However, the power of the leading video card should remain unchanged, i.e. it can't be reduced.
Vlad has an infinite amount of money so he can buy any set of video cards. Help him determine which video cards he should buy such that after picking the leading video card and may be reducing some powers of others to make them work together he will get the maximum total value of video power.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of video cards in the shop.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 200 000) — powers of video cards.
Output
The only line of the output should contain one integer value — the maximum possible total power of video cards working together.
Examples
Input
4
3 2 15 9
Output
27
Input
4
8 2 2 7
Output
18
Note
In the first sample, it would be optimal to buy video cards with powers 3, 15 and 9. The video card with power 3 should be chosen as the leading one and all other video cards will be compatible with it. Thus, the total power would be 3 + 15 + 9 = 27. If he buys all the video cards and pick the one with the power 2 as the leading, the powers of all other video cards should be reduced by 1, thus the total power would be 2 + 2 + 14 + 8 = 26, that is less than 27. Please note, that it's not allowed to reduce the power of the leading video card, i.e. one can't get the total power 3 + 1 + 15 + 9 = 28.
In the second sample, the optimal answer is to buy all video cards and pick the one with the power 2 as the leading. The video card with the power 7 needs it power to be reduced down to 6. The total power would be 8 + 2 + 2 + 6 = 18.
Submitted Solution:
```
size = int(input())
if size == 1:
print(input())
else:
arr = list(map(int,input().split()))
arr = sorted(arr)
MAX = 200001
arr_max = arr[-1]
count = [0] * MAX
cumm_sum = [0] * MAX
for i in arr:
count[i] += 1
for i in range(MAX):
cumm_sum[i] = cumm_sum[i-1] + count[i]
global_max = -1
for i in arr:
local_ans = 0
add = i
prev_val = i
next_val = i + add
while prev_val <= arr_max and next_val < MAX:
cnt_val = cumm_sum[next_val] - cumm_sum[prev_val]
local_ans += (cnt_val - count[next_val]) * prev_val + prev_val * count[prev_val]
prev_val = next_val
next_val += add
globalbal_max = max(global_max, local_ans)
print(global_max)
``` | instruction | 0 | 41,703 | 2 | 83,406 |
No | output | 1 | 41,703 | 2 | 83,407 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0 | instruction | 0 | 42,109 | 2 | 84,218 |
Tags: implementation
Correct Solution:
```
from decimal import Decimal
n, m, k = input().split()
k = Decimal(k)
n,m = int(n),int(m)
dic = {}
cnt = 0
for _ in range(n):
name, exp = input().split()
exp = int(exp)
exp = int(exp * k)
if exp < 100:
continue
else:
dic[name] = exp
cnt += 1
for _ in range(m):
name = input()
if name not in dic.keys():
dic[name] = 0
cnt += 1
print(cnt)
for key in sorted(dic.keys()):
print(key, dic[key])
``` | output | 1 | 42,109 | 2 | 84,219 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0 | instruction | 0 | 42,110 | 2 | 84,220 |
Tags: implementation
Correct Solution:
```
from collections import Counter
n, m, k = input().split()
k, c = int(k.split('.')[1]), Counter()
for i in range(int(n)):
s, e = input().split()
e = int(e) * k // 100
if e >= 100:
c[s] = e
for i in range(int(m)):
c[input()] += 0
print(len(c))
print('\n'.join(sorted(x + ' ' + str(c[x]) for x in c)))
``` | output | 1 | 42,110 | 2 | 84,221 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0 | instruction | 0 | 42,111 | 2 | 84,222 |
Tags: implementation
Correct Solution:
```
n,m,k=list(map(float,input().split()))
n=int(n)
m=int(m)
LIST_A=set([])
LIST_B=set([])
SKILLS=[]
d={}
for i in range(n):
skills,power=list(input().split())
LIST_A.add(skills)
SKILLS.append([skills,power])
d[skills]=power
# print(SKILLS)
# print(d)
TRANS=[]
L=[]
OP=[]
for i in range(m):
TRANS.append(input())
LIST_B.add(TRANS[-1])
if TRANS[-1] not in d:
L.append([TRANS[-1],'0'])
else:
OP.append(TRANS[-1])
# print(L)
# print(OP)
for i in range(len(OP)):
testicle=(str(k)[2:])
if len(testicle)==1:
testicle+='0'
testicle=int(testicle)
val=(int(d[OP[i]])*testicle)/100
if val>=100:
L.append([OP[i],str ( int( val)) ])
else:
L.append([OP[i],'0'])
cc=list(LIST_A.difference(LIST_B))
# print(cc)
for i in range(len(cc)):
testicle=(str(k)[2:])
if len(testicle)==1:
testicle+='0'
testicle=int(testicle)
val=(int(d[cc[i]])*testicle)/100
# print(val)
if val>=100:
L.append([cc[i],str( int( val) ) ])
# else:
# L.append([cc[i],'0'])
L.sort(key = lambda L: L[0])
print(len(L))
for i in range(len(L)):
print(*L[i])
``` | output | 1 | 42,111 | 2 | 84,223 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0 | instruction | 0 | 42,112 | 2 | 84,224 |
Tags: implementation
Correct Solution:
```
a=input().split()
n,m,k=int(a[0]),int(a[1]),int(a[2].split('.')[1])
b={}
for _ in range(n):
a=input().split()
c=int(a[1])*k/100
if c>=100: b[a[0]]=c
for _ in range(m):
d=input()
if not (d in b): b[d]=0
print(len(b))
for e in sorted(b):
print(e,int(b[e]))
``` | output | 1 | 42,112 | 2 | 84,225 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0 | instruction | 0 | 42,113 | 2 | 84,226 |
Tags: implementation
Correct Solution:
```
import math
n,m,k=input().split()
n=int(n);m=int(m);k=float(k)
ans=[];re=[]
for i in range(n):
q=0
x,y = input().split()
q += (.99999 <= (math.modf(int(y)*k)[0]))
if int(int(y)*k)+q > 99 :
ans.append([x , int(int(y)*k)+q])
re.append(x)
for j in range(m):
c=input()
if c not in re :
ans.append([c,0])
ans.sort()
print(len(ans))
for s,i in ans:
print(s,i)
``` | output | 1 | 42,113 | 2 | 84,227 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0 | instruction | 0 | 42,114 | 2 | 84,228 |
Tags: implementation
Correct Solution:
```
n,m,k=input().split()
n,m=int(n),int(m)
k=int(k[2:])
d={}
d2={}
ans=[]
for i in range(n):
a,b=input().split()
# print ((int(b)*int(str(k)[2:]))/100)
# print ((int(b)),str(k),str(k)[2:],int(str(k)[2:]),int(b)*int(str(k)[2:]),int(b)*int(str(k)[2:]))
if (int(b)*k/100)>=100:
d[a]=int(b)*k/100
for i in range(m):
s=input()
d2[s]=0
for i in d:
ans.append((i,d[i]))
for i in d2:
if i not in d:
ans.append((i,d2[i]))
ans.sort()
print (len(ans))
for i in ans:
print (i[0],int(i[1]))
``` | output | 1 | 42,114 | 2 | 84,229 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0 | instruction | 0 | 42,115 | 2 | 84,230 |
Tags: implementation
Correct Solution:
```
#!/usr/bin/env python3
ESP = 1e-7
n, m, k = input().rstrip().split()
n, m, k = int(n), int(m), float(k)
cur = {}
for i in range(n):
skill, exp = input().rstrip().split()
exp = int(int(exp) * k + ESP)
if exp >= 100:
cur[skill] = exp
for i in range(m):
skill = input().rstrip()
cur.setdefault(skill, 0)
print(len(cur))
for k in sorted(cur.keys()):
print(k, cur[k])
``` | output | 1 | 42,115 | 2 | 84,231 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0 | instruction | 0 | 42,116 | 2 | 84,232 |
Tags: implementation
Correct Solution:
```
import sys
from itertools import *
from math import *
def solve():
n, m, k = input().split()
n = int(n)
m = int(m)
k = int(k[2:])
skills = {}
for i in range(n):
name, level = input().split()
level = int(level)
newlevel = (k * level) // 100
if newlevel >= 100:
skills[name] = newlevel
for i in range(m):
name = input()
if name not in skills:
skills[name] = 0
print(len(skills))
ssskills = sorted(skills)
for name in ssskills:
print(name, skills[name])
if sys.hexversion == 50594544 : sys.stdin = open("test.txt")
solve()
``` | output | 1 | 42,116 | 2 | 84,233 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0
Submitted Solution:
```
n, m, k = input().split()
k = int(k[2:])
n = int(n)
m = int(m)
ans = {}
for i in range(n):
s, n = input().split()
n = int(n) * k // 100
if n < 100:
continue
ans[s] = n
for i in range(m):
s = input()
if not s in ans:
ans[s] = 0
print(len(ans))
for k, v in sorted(ans.items()):
print(k, v)
``` | instruction | 0 | 42,117 | 2 | 84,234 |
Yes | output | 1 | 42,117 | 2 | 84,235 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0
Submitted Solution:
```
data = input().split()
old_count, new_count = map(int, data[0:2])
percent = int(data[2][2:])
skills = {}
for i in range(old_count):
name, score = input().split()
score = int(score) * percent // 100
if score >= 100:
skills[name] = score
for i in range(new_count):
name = input().strip()
if name not in skills:
skills[name] = 0
print(len(skills))
for name, score in sorted(skills.items()):
print(name, score)
``` | instruction | 0 | 42,118 | 2 | 84,236 |
Yes | output | 1 | 42,118 | 2 | 84,237 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0
Submitted Solution:
```
n, m, k = input().split()
n, m = int(n), int(m)
k = int(k[2:])
skills = {}
for _ in range(n):
skill, val = map(str.strip, input().split())
val = int(val)
if int(val * k // 100) >= 100:
skills[skill] = int(val * k // 100)
for _ in range(m):
skill = input().strip()
if skill not in skills:
skills[skill] = 0
print(len(skills))
for skill, val in sorted(skills.items()):
print(skill, val)
``` | instruction | 0 | 42,119 | 2 | 84,238 |
Yes | output | 1 | 42,119 | 2 | 84,239 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0
Submitted Solution:
```
n,m,k=map(float,input().split())
n,m,k=round(n),round(m),round(k*100)
D=dict()
for i in range(n):
x=input().split()
F=int(x[1])*k//100
if(F>=100):
D[x[0]]=F
for i in range(m):
x=input()
if x not in D:D[x]=0
print(len(D))
for x in sorted(D):
print(x,D[x])
``` | instruction | 0 | 42,120 | 2 | 84,240 |
Yes | output | 1 | 42,120 | 2 | 84,241 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0
Submitted Solution:
```
n, m, k = input().split()
n = int(n)
m = int(m)
k = float(k)*100
k = int(k)
d = dict()
# print(k)
for i in range(n):
name, l = input().split()
if int(l)<100:
continue
else:
l = (int(l)*k)//100
if l<100:
continue
d[name] = l
for i in range(m):
inp = input()
if inp in d:
continue
else:
d[inp] = 0
s = list(d.keys())
# print(d)
s.sort()
print(len(s))
for i in s:
print(i, int(d[i]))
``` | instruction | 0 | 42,121 | 2 | 84,242 |
No | output | 1 | 42,121 | 2 | 84,243 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0
Submitted Solution:
```
'''input
5 0 0.75
axe 30
impaler 30
ionize 80
megafire 120
magicboost 20
heal
megafire
shield
magicboost
'''
q = input().split()
n = int(q[0])
m = int(q[1])
k = int(float(q[2])*100)
dicn = {}
for i in range(n):
a = input().split()
dicn[a[0]] = int(a[1])
a = list(dicn.keys())
b = [0]*n
for i in range(n):
b[i] = int((dicn[a[i]]*k)/100)
dicn1 = {}
for i in range(n):
if (b[i]>=100):
dicn1[a[i]]=b[i]
a = list(dicn1.keys())
for i in range(m):
l = input()
if l not in a:
dicn1[l] = 0
# print(dicn1)
a = list(dicn1.keys())
a.sort()
# print(a)
l = len(a)
print(l)
for i in range(l):
print(a[i],dicn1[a[i]])
``` | instruction | 0 | 42,122 | 2 | 84,244 |
No | output | 1 | 42,122 | 2 | 84,245 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0
Submitted Solution:
```
n, m, k = input().split()
n, m, k = int(n), int(m), float(k)
p = {}
for i in range(n):
a, b = input().split()
b = int(int(b) * k)
if b > 99: p[a] = b
for i in range(m):
a = input()
p[a] = p.get(a, 0)
t = sorted(list(p.keys()))
print(len(t))
for i in t: print(i, p[i])
``` | instruction | 0 | 42,123 | 2 | 84,246 |
No | output | 1 | 42,123 | 2 | 84,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0
Submitted Solution:
```
import sys
import math
n, m, k = (sys.stdin.readline()).split()
n = int(n)
m = int(m)
k = float(k)
d = dict()
c = 0
for i in range(n):
name, exp = (sys.stdin.readline()).split()
if name not in d:
v = int(math.ceil(float(exp) * k))
if(v >= 100):
c += 1
d[name] = v
for i in range(m):
name = (sys.stdin.readline()).split()[0]
if name not in d:
c += 1
d[name] = 0
print(c)
lk = list(d.keys())
lk.sort()
for i in lk:
print(str(i) + " " + str(d[i]))
``` | instruction | 0 | 42,124 | 2 | 84,248 |
No | output | 1 | 42,124 | 2 | 84,249 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yet another Armageddon is coming! This time the culprit is the Julya tribe calendar.
The beavers in this tribe knew math very well. Smart Beaver, an archaeologist, got a sacred plate with a magic integer on it. The translation from Old Beaverish is as follows:
"May the Great Beaver bless you! May your chacres open and may your third eye never turn blind from beholding the Truth! Take the magic number, subtract a digit from it (the digit must occur in the number) and get a new magic number. Repeat this operation until a magic number equals zero. The Earth will stand on Three Beavers for the time, equal to the number of subtractions you perform!"
Distinct subtraction sequences can obviously get you different number of operations. But the Smart Beaver is ready to face the worst and is asking you to count the minimum number of operations he needs to reduce the magic number to zero.
Input
The single line contains the magic integer n, 0 ≤ n.
* to get 20 points, you need to solve the problem with constraints: n ≤ 106 (subproblem C1);
* to get 40 points, you need to solve the problem with constraints: n ≤ 1012 (subproblems C1+C2);
* to get 100 points, you need to solve the problem with constraints: n ≤ 1018 (subproblems C1+C2+C3).
Output
Print a single integer — the minimum number of subtractions that turns the magic number to a zero.
Examples
Input
24
Output
5
Note
In the first test sample the minimum number of operations can be reached by the following sequence of subtractions:
24 → 20 → 18 → 10 → 9 → 0 | instruction | 0 | 42,416 | 2 | 84,832 |
Tags: dp
Correct Solution:
```
c = '0123456789'
F = {c[a] + c[b]: (c[10 - a + b], 1) if a > b else (c[10 - a], 2) for a in range(1, 10) for b in range(10)}
for b in range(1, 10): F['0' + c[b]] = ('0', 1)
F['00'] = ('0', 0)
def f(x):
global F
if x in F: return F[x]
a, b, y, s = int(x[0]), int(x[1]), x[2: ], 0
for i in range(b, a, -1):
y, d = f(c[i] + y)
s += d
for i in range(min(a, b) + 1):
y, d = f(x[0] + y)
s += d
F[x] = ('9' + y, s)
return F[x]
print(f('0' + input())[1])
``` | output | 1 | 42,416 | 2 | 84,833 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yet another Armageddon is coming! This time the culprit is the Julya tribe calendar.
The beavers in this tribe knew math very well. Smart Beaver, an archaeologist, got a sacred plate with a magic integer on it. The translation from Old Beaverish is as follows:
"May the Great Beaver bless you! May your chacres open and may your third eye never turn blind from beholding the Truth! Take the magic number, subtract a digit from it (the digit must occur in the number) and get a new magic number. Repeat this operation until a magic number equals zero. The Earth will stand on Three Beavers for the time, equal to the number of subtractions you perform!"
Distinct subtraction sequences can obviously get you different number of operations. But the Smart Beaver is ready to face the worst and is asking you to count the minimum number of operations he needs to reduce the magic number to zero.
Input
The single line contains the magic integer n, 0 ≤ n.
* to get 20 points, you need to solve the problem with constraints: n ≤ 106 (subproblem C1);
* to get 40 points, you need to solve the problem with constraints: n ≤ 1012 (subproblems C1+C2);
* to get 100 points, you need to solve the problem with constraints: n ≤ 1018 (subproblems C1+C2+C3).
Output
Print a single integer — the minimum number of subtractions that turns the magic number to a zero.
Examples
Input
24
Output
5
Note
In the first test sample the minimum number of operations can be reached by the following sequence of subtractions:
24 → 20 → 18 → 10 → 9 → 0 | instruction | 0 | 42,417 | 2 | 84,834 |
Tags: dp
Correct Solution:
```
memoization_table = {}
def compute_count(previous_max, rest):
global memoization_table
original_rest = rest
if (previous_max, rest) in memoization_table:
return memoization_table[(previous_max, rest)]
num_digits = len(str(rest))
if num_digits == 1:
memoization_table[(previous_max, original_rest)] = 1, min(0, rest-previous_max)
return 1, min(0, rest-previous_max)
sum_count = 0
while rest > 0:
s = str(rest).zfill(num_digits)
new_max = max(previous_max, int(s[0]))
new_rest = int(s[1:])
count, leftover = compute_count(new_max, new_rest)
sum_count += count
rest -= new_rest
rest += leftover
memoization_table[(previous_max, original_rest)] = sum_count, rest
return sum_count, rest
n=int(input())
ans=0
if n != 0: ans,not_ans=compute_count(0,n)
print(ans)
``` | output | 1 | 42,417 | 2 | 84,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yet another Armageddon is coming! This time the culprit is the Julya tribe calendar.
The beavers in this tribe knew math very well. Smart Beaver, an archaeologist, got a sacred plate with a magic integer on it. The translation from Old Beaverish is as follows:
"May the Great Beaver bless you! May your chacres open and may your third eye never turn blind from beholding the Truth! Take the magic number, subtract a digit from it (the digit must occur in the number) and get a new magic number. Repeat this operation until a magic number equals zero. The Earth will stand on Three Beavers for the time, equal to the number of subtractions you perform!"
Distinct subtraction sequences can obviously get you different number of operations. But the Smart Beaver is ready to face the worst and is asking you to count the minimum number of operations he needs to reduce the magic number to zero.
Input
The single line contains the magic integer n, 0 ≤ n.
* to get 20 points, you need to solve the problem with constraints: n ≤ 106 (subproblem C1);
* to get 40 points, you need to solve the problem with constraints: n ≤ 1012 (subproblems C1+C2);
* to get 100 points, you need to solve the problem with constraints: n ≤ 1018 (subproblems C1+C2+C3).
Output
Print a single integer — the minimum number of subtractions that turns the magic number to a zero.
Examples
Input
24
Output
5
Note
In the first test sample the minimum number of operations can be reached by the following sequence of subtractions:
24 → 20 → 18 → 10 → 9 → 0
Submitted Solution:
```
memoization_table = {}
def compute_count(previous_max, rest):
global memoization_table
original_rest = rest
if (previous_max, rest) in memoization_table:
return memoization_table[(previous_max, rest)]
num_digits = len(str(rest))
if num_digits == 1:
memoization_table[(previous_max, original_rest)] = 1, min(0, rest-previous_max)
return 1, min(0, rest-previous_max)
sum_count = 0
while rest > 0:
s = str(rest).zfill(num_digits)
new_max = max(previous_max, int(s[0]))
new_rest = int(s[1:])
count, leftover = compute_count(new_max, new_rest)
sum_count += count
rest -= new_rest
rest += leftover
memoization_table[(previous_max, original_rest)] = sum_count, rest
return sum_count, rest
n=int(input())
ans,not_ans=compute_count(0,n)
print(ans)
``` | instruction | 0 | 42,418 | 2 | 84,836 |
No | output | 1 | 42,418 | 2 | 84,837 |
Provide a correct Python 3 solution for this coding contest problem.
After having drifted about in a small boat for a couple of days, Akira Crusoe Maeda was finally cast ashore on a foggy island. Though he was exhausted and despaired, he was still fortunate to remember a legend of the foggy island, which he had heard from patriarchs in his childhood. This must be the island in the legend.
In the legend, two tribes have inhabited the island, one is divine and the other is devilish; once members of the divine tribe bless you, your future is bright and promising, and your soul will eventually go to Heaven; in contrast, once members of the devilish tribe curse you, your future is bleak and hopeless, and your soul will eventually fall down to Hell.
In order to prevent the worst-case scenario, Akira should distinguish the devilish from the divine. But how? They looked exactly alike and he could not distinguish one from the other solely by their appearances. He still had his last hope, however. The members of the divine tribe are truth-tellers, that is, they always tell the truth and those of the devilish tribe are liars, that is, they always tell a lie.
He asked some of the whether or not some are divine. They knew one another very much and always responded to him "faithfully" according to their individual natures (i.e., they always tell the truth or always a lie). He did not dare to ask any other forms of questions, since the legend says that a devilish member would curse a person forever when he did not like the question. He had another piece of useful information: the legend tells the populations of both tribes. These numbers in the legend are trustworthy since everyone living on this island is immortal and none have ever been born at least these millennia.
You are a good computer programmer and so requested to help Akira by writing a program that classifies the inhabitants according to their answers to his inquiries.
Input
The input consists of multiple data sets, each in the following format:
n p1 p2
x1 y1 a1
x2 y2 a2
...
xi yi ai
...
xn yn an
The first line has three non-negative integers n, p1, and p2. n is the number of questions Akira asked. p1 and p2 are the populations of the divine and devilish tribes, respectively, in the legend. Each of the following n lines has two integers xi, yi and one word ai. xi and yi are the identification numbers of inhabitants, each of which is between 1 and p1 + p2, inclusive. ai is either "yes", if the inhabitant xi said that the inhabitant yi was a member of the divine tribe, or "no", otherwise. Note that xi and yi can be the same number since "are you a member of the divine tribe?" is a valid question. Note also that two lines may have the same x's and y's since Akira was very upset and might have asked the same question to the same one more than once.
You may assume that n is less than 1000 and that p1 and p2 are less than 300. A line with three zeros, i.e., "0 0 0", represents the end of the input. You can assume that each data set is consistent and no contradictory answers are included.
Output
For each data set, if it includes sufficient information to classify all the inhabitants, print the identification numbers of all the divine ones in ascending order, one in a line. In addition, following the output numbers, print "end" in a line. Otherwise, i.e., if a given data set does not include sufficient information to identify all the divine members, print "no" in a line.
Example
Input
2 1 1
1 2 no
2 1 no
3 2 1
1 1 yes
2 2 yes
3 3 yes
2 2 1
1 2 yes
2 3 no
5 4 3
1 2 yes
1 3 no
4 5 yes
5 6 yes
6 7 no
0 0 0
Output
no
no
1
2
end
3
4
5
6
end | instruction | 0 | 42,843 | 2 | 85,686 |
"Correct Solution:
```
from collections import defaultdict
class UnionFind():
def __init__(self, n):
self.parent = list(range(n))
self.rank = [0] * n
def find(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x, y = self.find(x), self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
while True:
n, p1, p2 = (int(s) for s in input().split())
if (n, p1, p2) == (0, 0, 0):
break
p = p1 + p2
tree = UnionFind(p * 2)
unions = defaultdict(list)
for i in range(n):
xs, ys, a = input().split()
x, y = int(xs) - 1, int(ys) - 1
if a == 'yes':
tree.unite(x, y)
tree.unite(x + p, y + p)
else:
tree.unite(x, y + p)
tree.unite(x + p, y)
for i in range(p):
unions[tree.find(i)].append(i)
roots = []
sides = []
diffs = []
rest = p1
for i in range(p):
if i in unions:
member_len, backside_len = len(unions[i]), len(unions[i + p])
if member_len == backside_len:
rest = -1
break
elif member_len < backside_len:
diff = backside_len - member_len
rest -= member_len
sides.append(0)
else:
diff = member_len - backside_len
sides.append(1)
rest -= backside_len
roots.append(i)
diffs.append(diff)
if rest < 0:
print('no')
continue
dp = [[1] + [0] * rest for i in range(len(roots) + 1)]
for i in reversed(range(len(roots))):
for j in range(1, rest + 1):
if j < diffs[i]:
if dp[i + 1][j]:
dp[i][j] = 1
else:
dp[i][j] = 0
else:
if dp[i + 1][j] and dp[i + 1][j - diffs[i]]:
dp[i][j] = 3
elif dp[i + 1][j - diffs[i]]:
dp[i][j] = 2
elif dp[i + 1][j]:
dp[i][j] = 1
else:
dp[i][j] = 0
divines = []
for i in range(len(roots)):
if dp[i][rest] == 1:
divines.extend(unions[roots[i] + p * sides[i]])
elif dp[i][rest] == 2:
divines.extend(unions[roots[i] + p * (1 - sides[i])])
rest -= diffs[i]
else:
print('no')
break
else:
divines.sort()
for divine in divines:
print(divine + 1)
print('end')
``` | output | 1 | 42,843 | 2 | 85,687 |
Provide a correct Python 3 solution for this coding contest problem.
After having drifted about in a small boat for a couple of days, Akira Crusoe Maeda was finally cast ashore on a foggy island. Though he was exhausted and despaired, he was still fortunate to remember a legend of the foggy island, which he had heard from patriarchs in his childhood. This must be the island in the legend.
In the legend, two tribes have inhabited the island, one is divine and the other is devilish; once members of the divine tribe bless you, your future is bright and promising, and your soul will eventually go to Heaven; in contrast, once members of the devilish tribe curse you, your future is bleak and hopeless, and your soul will eventually fall down to Hell.
In order to prevent the worst-case scenario, Akira should distinguish the devilish from the divine. But how? They looked exactly alike and he could not distinguish one from the other solely by their appearances. He still had his last hope, however. The members of the divine tribe are truth-tellers, that is, they always tell the truth and those of the devilish tribe are liars, that is, they always tell a lie.
He asked some of the whether or not some are divine. They knew one another very much and always responded to him "faithfully" according to their individual natures (i.e., they always tell the truth or always a lie). He did not dare to ask any other forms of questions, since the legend says that a devilish member would curse a person forever when he did not like the question. He had another piece of useful information: the legend tells the populations of both tribes. These numbers in the legend are trustworthy since everyone living on this island is immortal and none have ever been born at least these millennia.
You are a good computer programmer and so requested to help Akira by writing a program that classifies the inhabitants according to their answers to his inquiries.
Input
The input consists of multiple data sets, each in the following format:
n p1 p2
x1 y1 a1
x2 y2 a2
...
xi yi ai
...
xn yn an
The first line has three non-negative integers n, p1, and p2. n is the number of questions Akira asked. p1 and p2 are the populations of the divine and devilish tribes, respectively, in the legend. Each of the following n lines has two integers xi, yi and one word ai. xi and yi are the identification numbers of inhabitants, each of which is between 1 and p1 + p2, inclusive. ai is either "yes", if the inhabitant xi said that the inhabitant yi was a member of the divine tribe, or "no", otherwise. Note that xi and yi can be the same number since "are you a member of the divine tribe?" is a valid question. Note also that two lines may have the same x's and y's since Akira was very upset and might have asked the same question to the same one more than once.
You may assume that n is less than 1000 and that p1 and p2 are less than 300. A line with three zeros, i.e., "0 0 0", represents the end of the input. You can assume that each data set is consistent and no contradictory answers are included.
Output
For each data set, if it includes sufficient information to classify all the inhabitants, print the identification numbers of all the divine ones in ascending order, one in a line. In addition, following the output numbers, print "end" in a line. Otherwise, i.e., if a given data set does not include sufficient information to identify all the divine members, print "no" in a line.
Example
Input
2 1 1
1 2 no
2 1 no
3 2 1
1 1 yes
2 2 yes
3 3 yes
2 2 1
1 2 yes
2 3 no
5 4 3
1 2 yes
1 3 no
4 5 yes
5 6 yes
6 7 no
0 0 0
Output
no
no
1
2
end
3
4
5
6
end | instruction | 0 | 42,844 | 2 | 85,688 |
"Correct Solution:
```
from collections import deque
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N, p1, p2 = map(int, readline().split())
if N == p1 == p2 == 0:
return False
P = p1 + p2
G = [[] for i in range(P)]
for i in range(N):
x, y, a = readline().strip().split()
x = int(x); y = int(y); d = (a == "no")
if x == y:
continue
G[x-1].append((y-1, d))
G[y-1].append((x-1, d))
L = [-1]*P
ok = 1
U = []
for i in range(P):
if L[i] != -1:
continue
que = deque([i])
L[i] = 0
cs = [[], []]
while que:
v = que.popleft()
e = L[v]
cs[e].append(v+1)
for w, d in G[v]:
if L[w] != -1:
continue
L[w] = e ^ d
que.append(w)
a, b = map(len, cs)
if a == b:
ok = 0
break
U.append((cs[0], cs[1]))
if not ok:
write("no\n")
return True
S = [0]*(p1+1)
S[0] = 1
SS = [S]
zeros = [0]*(p1+1)
M = len(U)
for c0, c1 in U:
p = len(c0); q = len(c1)
T = [0]*(p1+1)
for i in range(p1+1):
if S[i]:
if i+p <= p1:
T[i+p] += S[i]
if i+q <= p1:
T[i+q] += S[i]
SS.append(T)
S = T
if S[p1] > 1:
write("no\n")
return True
ans = []
rest = p1
for i in range(M-1, -1, -1):
T0 = SS[i]
c0, c1 = U[i]
p = len(c0); q = len(c1)
if rest - p >= 0 and T0[rest - p]:
ans.extend(c0)
rest -= p
else:
ans.extend(c1)
rest -= q
if ans:
ans.sort()
write("\n".join(map(str, ans)))
write("\n")
write("end\n")
return True
while solve():
...
``` | output | 1 | 42,844 | 2 | 85,689 |
Provide a correct Python 3 solution for this coding contest problem.
After having drifted about in a small boat for a couple of days, Akira Crusoe Maeda was finally cast ashore on a foggy island. Though he was exhausted and despaired, he was still fortunate to remember a legend of the foggy island, which he had heard from patriarchs in his childhood. This must be the island in the legend.
In the legend, two tribes have inhabited the island, one is divine and the other is devilish; once members of the divine tribe bless you, your future is bright and promising, and your soul will eventually go to Heaven; in contrast, once members of the devilish tribe curse you, your future is bleak and hopeless, and your soul will eventually fall down to Hell.
In order to prevent the worst-case scenario, Akira should distinguish the devilish from the divine. But how? They looked exactly alike and he could not distinguish one from the other solely by their appearances. He still had his last hope, however. The members of the divine tribe are truth-tellers, that is, they always tell the truth and those of the devilish tribe are liars, that is, they always tell a lie.
He asked some of the whether or not some are divine. They knew one another very much and always responded to him "faithfully" according to their individual natures (i.e., they always tell the truth or always a lie). He did not dare to ask any other forms of questions, since the legend says that a devilish member would curse a person forever when he did not like the question. He had another piece of useful information: the legend tells the populations of both tribes. These numbers in the legend are trustworthy since everyone living on this island is immortal and none have ever been born at least these millennia.
You are a good computer programmer and so requested to help Akira by writing a program that classifies the inhabitants according to their answers to his inquiries.
Input
The input consists of multiple data sets, each in the following format:
n p1 p2
x1 y1 a1
x2 y2 a2
...
xi yi ai
...
xn yn an
The first line has three non-negative integers n, p1, and p2. n is the number of questions Akira asked. p1 and p2 are the populations of the divine and devilish tribes, respectively, in the legend. Each of the following n lines has two integers xi, yi and one word ai. xi and yi are the identification numbers of inhabitants, each of which is between 1 and p1 + p2, inclusive. ai is either "yes", if the inhabitant xi said that the inhabitant yi was a member of the divine tribe, or "no", otherwise. Note that xi and yi can be the same number since "are you a member of the divine tribe?" is a valid question. Note also that two lines may have the same x's and y's since Akira was very upset and might have asked the same question to the same one more than once.
You may assume that n is less than 1000 and that p1 and p2 are less than 300. A line with three zeros, i.e., "0 0 0", represents the end of the input. You can assume that each data set is consistent and no contradictory answers are included.
Output
For each data set, if it includes sufficient information to classify all the inhabitants, print the identification numbers of all the divine ones in ascending order, one in a line. In addition, following the output numbers, print "end" in a line. Otherwise, i.e., if a given data set does not include sufficient information to identify all the divine members, print "no" in a line.
Example
Input
2 1 1
1 2 no
2 1 no
3 2 1
1 1 yes
2 2 yes
3 3 yes
2 2 1
1 2 yes
2 3 no
5 4 3
1 2 yes
1 3 no
4 5 yes
5 6 yes
6 7 no
0 0 0
Output
no
no
1
2
end
3
4
5
6
end | instruction | 0 | 42,845 | 2 | 85,690 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15
class UnionFind():
def __init__(self,n):
self.n = n
self.parents = [-1]*n
def find(self,x): #根を見つける、繋ぎ直す
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def unite(self,x,y): #x,yの含むグループを併合する
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x,y = y,x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self,x,y):#xとyが同じグループにいるか判定
return self.find(x) == self.find(y)
def members(self,x):#xと同じグループのメンバーを列挙
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def size(self,x):#xが属するグループのメンバーの数
return -self.parents[self.find(x)]
def roots(self):#ufの根を列挙
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):#グループの数を数える
return len(self.roots())
def all_group_members(self):#根:メンバの辞書を返す
return {r: self.members(r) for r in self.roots()}
def solve(N,P,Q):
M = P + Q
uf = UnionFind(M + M)
flag = True
for _ in range(N):
q = input().split()
x = int(q[0]) - 1
y = int(q[1]) - 1
a = q[2]
if a == 'yes':
if x == y:
continue
if uf.same(x,y + M) or uf.same(x + M,y):
flag = False
break
uf.unite(x,y)
uf.unite(x + M,y + M)
else:
if x == y:
flag = False
break
if uf.same(x,y) or uf.same(x + M,y + M):
flag = False
break
uf.unite(x,y + M)
uf.unite(x + M,y)
if not flag:
print('no')
return
for i in range(M):
if uf.same(i,i + M):
print('no')
return
root = uf.roots()
member = uf.all_group_members()
each_god = []
before_searched = [0] * M
candidate = []
for r in root:
god = 0
evil = 0
flag = True
for m in member[r]:
if m < M:
if before_searched[m] == 1:
flag = False
break
else:
god += 1
before_searched[m] = 1
else:
if before_searched[m - M] == 1:
flag = False
break
else:
evil += 1
before_searched[m - M] = 1
if flag:
candidate.append(r)
each_god.append((god,evil))
dp = [[0]*(1 + P) for _ in range(len(candidate) + 1)]
if each_god[0][0] <= P:
dp[1][each_god[0][0]] = 1
if each_god[0][1] <= P:
dp[1][each_god[0][1]] += 1
for i,(g,e) in enumerate(each_god[1:],1):
for j in range(P + 1):
if j - e >= 0:
dp[i + 1][j] += dp[i][j - e]
if j - g >= 0:
dp[i + 1][j] += dp[i][j - g]
#print('each_god: ',each_god)
#print('candidate ',candidate)
#print('dp: ',dp)
if dp[-1][P] == 1:
ans = []
now = P
for i in range(len(candidate) - 1,0,-1):
if 0 <= now - each_god[i][0] <= P and dp[i][now - each_god[i][0]] == 1:
for m in member[candidate[i]]:
if m < M:
ans.append(m + 1)
now -= each_god[i][0]
elif 0 <= now - each_god[i][1] <= P and dp[i][now - each_god[i][1]] == 1:
for m in member[candidate[i]]:
if m >= M:
ans.append(m - M + 1)
now -= each_god[i][1]
if now > 0:
if now == each_god[0][0]:
for m in member[candidate[0]]:
if m < M:
ans.append(m + 1)
elif now == each_god[0][1]:
for m in member[candidate[0]]:
if m >= M:
ans.append(m - M + 1)
ans.sort()
if ans:
print('\n'.join(map(str,ans)))
print('end')
else:
print('no')
def main():
while True:
N,P,Q = map(int,input().split())
if N == 0 and P == 0 and Q == 0:
return
solve(N,P,Q)
if __name__ == '__main__':
main()
``` | output | 1 | 42,845 | 2 | 85,691 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After having drifted about in a small boat for a couple of days, Akira Crusoe Maeda was finally cast ashore on a foggy island. Though he was exhausted and despaired, he was still fortunate to remember a legend of the foggy island, which he had heard from patriarchs in his childhood. This must be the island in the legend.
In the legend, two tribes have inhabited the island, one is divine and the other is devilish; once members of the divine tribe bless you, your future is bright and promising, and your soul will eventually go to Heaven; in contrast, once members of the devilish tribe curse you, your future is bleak and hopeless, and your soul will eventually fall down to Hell.
In order to prevent the worst-case scenario, Akira should distinguish the devilish from the divine. But how? They looked exactly alike and he could not distinguish one from the other solely by their appearances. He still had his last hope, however. The members of the divine tribe are truth-tellers, that is, they always tell the truth and those of the devilish tribe are liars, that is, they always tell a lie.
He asked some of the whether or not some are divine. They knew one another very much and always responded to him "faithfully" according to their individual natures (i.e., they always tell the truth or always a lie). He did not dare to ask any other forms of questions, since the legend says that a devilish member would curse a person forever when he did not like the question. He had another piece of useful information: the legend tells the populations of both tribes. These numbers in the legend are trustworthy since everyone living on this island is immortal and none have ever been born at least these millennia.
You are a good computer programmer and so requested to help Akira by writing a program that classifies the inhabitants according to their answers to his inquiries.
Input
The input consists of multiple data sets, each in the following format:
n p1 p2
x1 y1 a1
x2 y2 a2
...
xi yi ai
...
xn yn an
The first line has three non-negative integers n, p1, and p2. n is the number of questions Akira asked. p1 and p2 are the populations of the divine and devilish tribes, respectively, in the legend. Each of the following n lines has two integers xi, yi and one word ai. xi and yi are the identification numbers of inhabitants, each of which is between 1 and p1 + p2, inclusive. ai is either "yes", if the inhabitant xi said that the inhabitant yi was a member of the divine tribe, or "no", otherwise. Note that xi and yi can be the same number since "are you a member of the divine tribe?" is a valid question. Note also that two lines may have the same x's and y's since Akira was very upset and might have asked the same question to the same one more than once.
You may assume that n is less than 1000 and that p1 and p2 are less than 300. A line with three zeros, i.e., "0 0 0", represents the end of the input. You can assume that each data set is consistent and no contradictory answers are included.
Output
For each data set, if it includes sufficient information to classify all the inhabitants, print the identification numbers of all the divine ones in ascending order, one in a line. In addition, following the output numbers, print "end" in a line. Otherwise, i.e., if a given data set does not include sufficient information to identify all the divine members, print "no" in a line.
Example
Input
2 1 1
1 2 no
2 1 no
3 2 1
1 1 yes
2 2 yes
3 3 yes
2 2 1
1 2 yes
2 3 no
5 4 3
1 2 yes
1 3 no
4 5 yes
5 6 yes
6 7 no
0 0 0
Output
no
no
1
2
end
3
4
5
6
end
Submitted Solution:
```
from collections import defaultdict
class UnionFind():
def __init__(self, n):
self.parent = list(range(n))
self.rank = [0] * n
def find(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x, y = self.find(x), self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
while True:
n, p1, p2 = (int(s) for s in input().split())
if not n:
break
p = p1 + p2
tree = UnionFind(p * 2)
unions = defaultdict(list)
for i in range(n):
xs, ys, a = input().split()
x, y = int(xs) - 1, int(ys) - 1
if a == 'yes':
tree.unite(x, y)
tree.unite(x + p, y + p)
else:
tree.unite(x, y + p)
tree.unite(x + p, y)
for i in range(p):
unions[tree.find(i)].append(i)
roots = []
sides = []
diffs = []
rest = p1
for i in range(p):
if i in unions:
member_len, backside_len = len(unions[i]), len(unions[i + p])
if member_len == backside_len:
rest = -1
break
elif member_len < backside_len:
diff = backside_len - member_len
rest -= member_len
sides.append(0)
else:
diff = member_len - backside_len
sides.append(1)
rest -= backside_len
roots.append(i)
diffs.append(diff)
if rest < 0:
print('no')
continue
dp = [[1] + [0] * rest for i in range(len(roots) + 1)]
for i in reversed(range(len(roots))):
for j in range(1, rest + 1):
if j < diffs[i]:
if dp[i + 1][j]:
dp[i][j] = 1
else:
dp[i][j] = 0
else:
if dp[i + 1][j] and dp[i + 1][j - diffs[i]]:
dp[i][j] = 3
elif dp[i + 1][j - diffs[i]]:
dp[i][j] = 2
elif dp[i + 1][j]:
dp[i][j] = 1
else:
dp[i][j] = 0
divines = []
for i in range(len(roots)):
if dp[i][rest] == 1:
divines.extend(unions[roots[i] + p * sides[i]])
elif dp[i][rest] == 2:
divines.extend(unions[roots[i] + p * (1 - sides[i])])
rest -= diffs[i]
else:
print('no')
break
else:
divines.sort()
for divine in divines:
print(divine + 1)
print('end')
``` | instruction | 0 | 42,846 | 2 | 85,692 |
No | output | 1 | 42,846 | 2 | 85,693 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After having drifted about in a small boat for a couple of days, Akira Crusoe Maeda was finally cast ashore on a foggy island. Though he was exhausted and despaired, he was still fortunate to remember a legend of the foggy island, which he had heard from patriarchs in his childhood. This must be the island in the legend.
In the legend, two tribes have inhabited the island, one is divine and the other is devilish; once members of the divine tribe bless you, your future is bright and promising, and your soul will eventually go to Heaven; in contrast, once members of the devilish tribe curse you, your future is bleak and hopeless, and your soul will eventually fall down to Hell.
In order to prevent the worst-case scenario, Akira should distinguish the devilish from the divine. But how? They looked exactly alike and he could not distinguish one from the other solely by their appearances. He still had his last hope, however. The members of the divine tribe are truth-tellers, that is, they always tell the truth and those of the devilish tribe are liars, that is, they always tell a lie.
He asked some of the whether or not some are divine. They knew one another very much and always responded to him "faithfully" according to their individual natures (i.e., they always tell the truth or always a lie). He did not dare to ask any other forms of questions, since the legend says that a devilish member would curse a person forever when he did not like the question. He had another piece of useful information: the legend tells the populations of both tribes. These numbers in the legend are trustworthy since everyone living on this island is immortal and none have ever been born at least these millennia.
You are a good computer programmer and so requested to help Akira by writing a program that classifies the inhabitants according to their answers to his inquiries.
Input
The input consists of multiple data sets, each in the following format:
n p1 p2
x1 y1 a1
x2 y2 a2
...
xi yi ai
...
xn yn an
The first line has three non-negative integers n, p1, and p2. n is the number of questions Akira asked. p1 and p2 are the populations of the divine and devilish tribes, respectively, in the legend. Each of the following n lines has two integers xi, yi and one word ai. xi and yi are the identification numbers of inhabitants, each of which is between 1 and p1 + p2, inclusive. ai is either "yes", if the inhabitant xi said that the inhabitant yi was a member of the divine tribe, or "no", otherwise. Note that xi and yi can be the same number since "are you a member of the divine tribe?" is a valid question. Note also that two lines may have the same x's and y's since Akira was very upset and might have asked the same question to the same one more than once.
You may assume that n is less than 1000 and that p1 and p2 are less than 300. A line with three zeros, i.e., "0 0 0", represents the end of the input. You can assume that each data set is consistent and no contradictory answers are included.
Output
For each data set, if it includes sufficient information to classify all the inhabitants, print the identification numbers of all the divine ones in ascending order, one in a line. In addition, following the output numbers, print "end" in a line. Otherwise, i.e., if a given data set does not include sufficient information to identify all the divine members, print "no" in a line.
Example
Input
2 1 1
1 2 no
2 1 no
3 2 1
1 1 yes
2 2 yes
3 3 yes
2 2 1
1 2 yes
2 3 no
5 4 3
1 2 yes
1 3 no
4 5 yes
5 6 yes
6 7 no
0 0 0
Output
no
no
1
2
end
3
4
5
6
end
Submitted Solution:
```
from collections import defaultdict
class UnionFind():
def __init__(self, n):
self.parent = list(range(n))
self.rank = [0] * n
def find(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x, y = self.find(x), self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
while True:
n, p1, p2 = (int(s) for s in input().split())
if not n:
break
p = p1 + p2
tree = UnionFind(p * 2)
unions = defaultdict(list)
for i in range(n):
xs, ys, a = input().split()
x, y = int(xs) - 1, int(ys) - 1
if a == 'yes':
tree.unite(x, y)
tree.unite(x + p, y + p)
else:
tree.unite(x, y + p)
tree.unite(x + p, y)
for i in range(p):
unions[tree.find(i)].append(i)
roots = []
sides = []
diffs = []
rest = p1
for i in range(p):
if i in unions:
member_len, foelen = len(unions[i]), len(unions[i + p])
if memlen == foelen:
rest = -1
break
elif memlen < foelen:
diff = foelen - memlen
rest -= memlen
sides.append(0)
else:
diff = memlen - foelen
sides.append(1)
rest -= foelen
roots.append(i)
diffs.append(diff)
if rest < 0:
print('no')
continue
dp = [[1] + [0] * rest for i in range(len(roots) + 1)]
for i in reversed(range(len(roots))):
for j in range(1, rest + 1):
if j < diffs[i]:
if dp[i + 1][j]:
dp[i][j] = 1
else:
dp[i][j] = 0
else:
if dp[i + 1][j] and dp[i + 1][j - diffs[i]]:
dp[i][j] = 3
elif dp[i + 1][j - diffs[i]]:
dp[i][j] = 2
elif dp[i + 1][j]:
dp[i][j] = 1
else:
dp[i][j] = 0
divines = []
for i in range(len(roots)):
if dp[i][rest] == 1:
divines.extend(unions[roots[i] + p * sides[i]])
elif dp[i][rest] == 2:
divines.extend(unions[roots[i] + p * (1 - sides[i])])
rest -= diffs[i]
else:
print('no')
break
else:
divines.sort()
for div in divines:
print(div + 1)
print('end')
``` | instruction | 0 | 42,847 | 2 | 85,694 |
No | output | 1 | 42,847 | 2 | 85,695 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing a game where your character should overcome different obstacles. The current problem is to come down from a cliff. The cliff has height h, and there is a moving platform on each height x from 1 to h.
Each platform is either hidden inside the cliff or moved out. At first, there are n moved out platforms on heights p_1, p_2, ..., p_n. The platform on height h is moved out (and the character is initially standing there).
If you character is standing on some moved out platform on height x, then he can pull a special lever, which switches the state of two platforms: on height x and x - 1. In other words, the platform you are currently standing on will hide in the cliff and the platform one unit below will change it state: it will hide if it was moved out or move out if it was hidden. In the second case, you will safely land on it. Note that this is the only way to move from one platform to another.
Your character is quite fragile, so it can safely fall from the height no more than 2. In other words falling from the platform x to platform x - 2 is okay, but falling from x to x - 3 (or lower) is certain death.
Sometimes it's not possible to come down from the cliff, but you can always buy (for donate currency) several magic crystals. Each magic crystal can be used to change the state of any single platform (except platform on height h, which is unaffected by the crystals). After being used, the crystal disappears.
What is the minimum number of magic crystal you need to buy to safely land on the 0 ground level?
Input
The first line contains one integer q (1 ≤ q ≤ 100) — the number of queries. Each query contains two lines and is independent of all other queries.
The first line of each query contains two integers h and n (1 ≤ h ≤ 10^9, 1 ≤ n ≤ min(h, 2 ⋅ 10^5)) — the height of the cliff and the number of moved out platforms.
The second line contains n integers p_1, p_2, ..., p_n (h = p_1 > p_2 > ... > p_n ≥ 1) — the corresponding moved out platforms in the descending order of their heights.
The sum of n over all queries does not exceed 2 ⋅ 10^5.
Output
For each query print one integer — the minimum number of magic crystals you have to spend to safely come down on the ground level (with height 0).
Example
Input
4
3 2
3 1
8 6
8 7 6 5 3 2
9 6
9 8 5 4 3 1
1 1
1
Output
0
1
2
0 | instruction | 0 | 43,037 | 2 | 86,074 |
Tags: dp, greedy, math
Correct Solution:
```
for q in range(int(input())):
h,n=map(int,input().split())
p=list(map(int,input().split()))
p.append(0)
ans=0
i=1
while i<n:
if p[i]==p[i+1]+1:
i+=2
else:
i+=1
ans+=1
print(ans)
``` | output | 1 | 43,037 | 2 | 86,075 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing a game where your character should overcome different obstacles. The current problem is to come down from a cliff. The cliff has height h, and there is a moving platform on each height x from 1 to h.
Each platform is either hidden inside the cliff or moved out. At first, there are n moved out platforms on heights p_1, p_2, ..., p_n. The platform on height h is moved out (and the character is initially standing there).
If you character is standing on some moved out platform on height x, then he can pull a special lever, which switches the state of two platforms: on height x and x - 1. In other words, the platform you are currently standing on will hide in the cliff and the platform one unit below will change it state: it will hide if it was moved out or move out if it was hidden. In the second case, you will safely land on it. Note that this is the only way to move from one platform to another.
Your character is quite fragile, so it can safely fall from the height no more than 2. In other words falling from the platform x to platform x - 2 is okay, but falling from x to x - 3 (or lower) is certain death.
Sometimes it's not possible to come down from the cliff, but you can always buy (for donate currency) several magic crystals. Each magic crystal can be used to change the state of any single platform (except platform on height h, which is unaffected by the crystals). After being used, the crystal disappears.
What is the minimum number of magic crystal you need to buy to safely land on the 0 ground level?
Input
The first line contains one integer q (1 ≤ q ≤ 100) — the number of queries. Each query contains two lines and is independent of all other queries.
The first line of each query contains two integers h and n (1 ≤ h ≤ 10^9, 1 ≤ n ≤ min(h, 2 ⋅ 10^5)) — the height of the cliff and the number of moved out platforms.
The second line contains n integers p_1, p_2, ..., p_n (h = p_1 > p_2 > ... > p_n ≥ 1) — the corresponding moved out platforms in the descending order of their heights.
The sum of n over all queries does not exceed 2 ⋅ 10^5.
Output
For each query print one integer — the minimum number of magic crystals you have to spend to safely come down on the ground level (with height 0).
Example
Input
4
3 2
3 1
8 6
8 7 6 5 3 2
9 6
9 8 5 4 3 1
1 1
1
Output
0
1
2
0 | instruction | 0 | 43,038 | 2 | 86,076 |
Tags: dp, greedy, math
Correct Solution:
```
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
for _ in range(INT()):
H, N = MAP()
A = LIST() + ([0]*2)
ans = 0
i = 0
while i < N:
if A[i+1] - A[i+2] <= 1:
i += 2
else:
ans += 1
A[i+1] += 1
i += 1
print(ans)
``` | output | 1 | 43,038 | 2 | 86,077 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing a game where your character should overcome different obstacles. The current problem is to come down from a cliff. The cliff has height h, and there is a moving platform on each height x from 1 to h.
Each platform is either hidden inside the cliff or moved out. At first, there are n moved out platforms on heights p_1, p_2, ..., p_n. The platform on height h is moved out (and the character is initially standing there).
If you character is standing on some moved out platform on height x, then he can pull a special lever, which switches the state of two platforms: on height x and x - 1. In other words, the platform you are currently standing on will hide in the cliff and the platform one unit below will change it state: it will hide if it was moved out or move out if it was hidden. In the second case, you will safely land on it. Note that this is the only way to move from one platform to another.
Your character is quite fragile, so it can safely fall from the height no more than 2. In other words falling from the platform x to platform x - 2 is okay, but falling from x to x - 3 (or lower) is certain death.
Sometimes it's not possible to come down from the cliff, but you can always buy (for donate currency) several magic crystals. Each magic crystal can be used to change the state of any single platform (except platform on height h, which is unaffected by the crystals). After being used, the crystal disappears.
What is the minimum number of magic crystal you need to buy to safely land on the 0 ground level?
Input
The first line contains one integer q (1 ≤ q ≤ 100) — the number of queries. Each query contains two lines and is independent of all other queries.
The first line of each query contains two integers h and n (1 ≤ h ≤ 10^9, 1 ≤ n ≤ min(h, 2 ⋅ 10^5)) — the height of the cliff and the number of moved out platforms.
The second line contains n integers p_1, p_2, ..., p_n (h = p_1 > p_2 > ... > p_n ≥ 1) — the corresponding moved out platforms in the descending order of their heights.
The sum of n over all queries does not exceed 2 ⋅ 10^5.
Output
For each query print one integer — the minimum number of magic crystals you have to spend to safely come down on the ground level (with height 0).
Example
Input
4
3 2
3 1
8 6
8 7 6 5 3 2
9 6
9 8 5 4 3 1
1 1
1
Output
0
1
2
0 | instruction | 0 | 43,039 | 2 | 86,078 |
Tags: dp, greedy, math
Correct Solution:
```
q = int(input());
size = 2*100000+1;
res = [];
p = [0 for i in range(size)];
d = [0 for i in range(size)];
for k in range(0, q):
h, n = [int(x) for x in input().split()];
p = list(map(int, input().split()));
d[0] = 0;
d[1] = 1;
for i in range(2, n):
if p[i-1] == p[i]+1:
d[i] = min(d[i-2], d[i-1] + 1);
else:
d[i] = min(d[i-2]+2, d[i-1]+1);
if p[n-1] == 1:
d[n] = min(d[n-2], d[n-1]);
elif p[n-1] == 2:
d[n] = min(d[n-2]+2, d[n-1]);
else:
d[n] = min(d[n-2]+2, d[n-1]);
if n == 1:
d[n] = 0;
res.append(d[n]);
for i in range(0, q):
print(res[i]);
``` | output | 1 | 43,039 | 2 | 86,079 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing a game where your character should overcome different obstacles. The current problem is to come down from a cliff. The cliff has height h, and there is a moving platform on each height x from 1 to h.
Each platform is either hidden inside the cliff or moved out. At first, there are n moved out platforms on heights p_1, p_2, ..., p_n. The platform on height h is moved out (and the character is initially standing there).
If you character is standing on some moved out platform on height x, then he can pull a special lever, which switches the state of two platforms: on height x and x - 1. In other words, the platform you are currently standing on will hide in the cliff and the platform one unit below will change it state: it will hide if it was moved out or move out if it was hidden. In the second case, you will safely land on it. Note that this is the only way to move from one platform to another.
Your character is quite fragile, so it can safely fall from the height no more than 2. In other words falling from the platform x to platform x - 2 is okay, but falling from x to x - 3 (or lower) is certain death.
Sometimes it's not possible to come down from the cliff, but you can always buy (for donate currency) several magic crystals. Each magic crystal can be used to change the state of any single platform (except platform on height h, which is unaffected by the crystals). After being used, the crystal disappears.
What is the minimum number of magic crystal you need to buy to safely land on the 0 ground level?
Input
The first line contains one integer q (1 ≤ q ≤ 100) — the number of queries. Each query contains two lines and is independent of all other queries.
The first line of each query contains two integers h and n (1 ≤ h ≤ 10^9, 1 ≤ n ≤ min(h, 2 ⋅ 10^5)) — the height of the cliff and the number of moved out platforms.
The second line contains n integers p_1, p_2, ..., p_n (h = p_1 > p_2 > ... > p_n ≥ 1) — the corresponding moved out platforms in the descending order of their heights.
The sum of n over all queries does not exceed 2 ⋅ 10^5.
Output
For each query print one integer — the minimum number of magic crystals you have to spend to safely come down on the ground level (with height 0).
Example
Input
4
3 2
3 1
8 6
8 7 6 5 3 2
9 6
9 8 5 4 3 1
1 1
1
Output
0
1
2
0 | instruction | 0 | 43,040 | 2 | 86,080 |
Tags: dp, greedy, math
Correct Solution:
```
from math import *
t = int(input())
for i in range(t):
n,r = map(int,input().split())
l = list(map(int,input().split()))
l.append(0)
l = l[::-1]
if(n <= 2):
print(0)
else:
ct = 0
i = r
while(i > 1):
#print(l[i],end = " ")
if(l[i] - l[i-1] == 1 and l[i] - l[i-2] != 2):
ct += 1
l[i-1] -= 1
i -= 1
elif(l[i] - l[i-1] == 1):
i -= 2
else:
l[i] = l[i-1]+1
print(ct)
``` | output | 1 | 43,040 | 2 | 86,081 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing a game where your character should overcome different obstacles. The current problem is to come down from a cliff. The cliff has height h, and there is a moving platform on each height x from 1 to h.
Each platform is either hidden inside the cliff or moved out. At first, there are n moved out platforms on heights p_1, p_2, ..., p_n. The platform on height h is moved out (and the character is initially standing there).
If you character is standing on some moved out platform on height x, then he can pull a special lever, which switches the state of two platforms: on height x and x - 1. In other words, the platform you are currently standing on will hide in the cliff and the platform one unit below will change it state: it will hide if it was moved out or move out if it was hidden. In the second case, you will safely land on it. Note that this is the only way to move from one platform to another.
Your character is quite fragile, so it can safely fall from the height no more than 2. In other words falling from the platform x to platform x - 2 is okay, but falling from x to x - 3 (or lower) is certain death.
Sometimes it's not possible to come down from the cliff, but you can always buy (for donate currency) several magic crystals. Each magic crystal can be used to change the state of any single platform (except platform on height h, which is unaffected by the crystals). After being used, the crystal disappears.
What is the minimum number of magic crystal you need to buy to safely land on the 0 ground level?
Input
The first line contains one integer q (1 ≤ q ≤ 100) — the number of queries. Each query contains two lines and is independent of all other queries.
The first line of each query contains two integers h and n (1 ≤ h ≤ 10^9, 1 ≤ n ≤ min(h, 2 ⋅ 10^5)) — the height of the cliff and the number of moved out platforms.
The second line contains n integers p_1, p_2, ..., p_n (h = p_1 > p_2 > ... > p_n ≥ 1) — the corresponding moved out platforms in the descending order of their heights.
The sum of n over all queries does not exceed 2 ⋅ 10^5.
Output
For each query print one integer — the minimum number of magic crystals you have to spend to safely come down on the ground level (with height 0).
Example
Input
4
3 2
3 1
8 6
8 7 6 5 3 2
9 6
9 8 5 4 3 1
1 1
1
Output
0
1
2
0 | instruction | 0 | 43,041 | 2 | 86,082 |
Tags: dp, greedy, math
Correct Solution:
```
import sys
import itertools
import math
import collections
from collections import Counter
#########################
# imgur.com/Pkt7iIf.png #
#########################
def pow(x, y, mod):
r = 1
x = x % mod
while y > 0:
if y & 1:
r = (r * x) % mod
y = y >> 1
x = (x * x) % mod
return r
def sieve(n):
prime = [True for i in range(n + 1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 1
prime[0] = prime[1] = False
r = [p for p in range(n + 1) if prime[p]]
return r
def divs(n, start = 1):
r = []
for i in range(start, int(math.sqrt(n) + 1)):
if (n % i == 0):
if (n / i == i):
r.append(i)
else:
r.extend([i, n // i])
return r
def cdiv(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a * b) // math.gcd(a, b)
def prr(a, sep = ' '): print(sep.join(map(str, a)))
def dd(): return collections.defaultdict(int)
q = ii()
for _ in range(q):
h, n = mi()
d = li()
d.append(0)
d.append(0)
i = 0
r = 0
while i < n - 1:
if d[i] <= 2:
break
if d[i] - d[i + 1] >= 2:
d[i] = d[i + 1] + 1
continue
if d[i] - d[i + 2] == 2:
i += 2
else:
r += 1
d[i + 1] = d[i + 2] + 1
i = i + 1
print(r)
``` | output | 1 | 43,041 | 2 | 86,083 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.