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
|
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova plays a computer game known as Mages and Monsters. Vova's character is a mage. Though as he has just started, his character knows no spells.
Vova's character can learn new spells during the game. Every spell is characterized by two values xi and yi — damage per second and mana cost per second, respectively. Vova doesn't have to use a spell for an integer amount of seconds. More formally, if he uses a spell with damage x and mana cost y for z seconds, then he will deal x·z damage and spend y·z mana (no rounding). If there is no mana left (mana amount is set in the start of the game and it remains the same at the beginning of every fight), then character won't be able to use any spells. It is prohibited to use multiple spells simultaneously.
Also Vova can fight monsters. Every monster is characterized by two values tj and hj — monster kills Vova's character in tj seconds and has hj health points. Mana refills after every fight (or Vova's character revives with full mana reserve), so previous fights have no influence on further ones.
Vova's character kills a monster, if he deals hj damage to it in no more than tj seconds using his spells (it is allowed to use more than one spell in a fight) and spending no more mana than he had at the beginning of the fight. If monster's health becomes zero exactly in tj seconds (it means that the monster and Vova's character kill each other at the same time), then Vova wins the fight.
You have to write a program which can answer two types of queries:
* 1 x y — Vova's character learns new spell which deals x damage per second and costs y mana per second.
* 2 t h — Vova fights the monster which kills his character in t seconds and has h health points.
Note that queries are given in a different form. Also remember that Vova's character knows no spells at the beginning of the game.
For every query of second type you have to determine if Vova is able to win the fight with corresponding monster.
Input
The first line contains two integer numbers q and m (2 ≤ q ≤ 105, 1 ≤ m ≤ 1012) — the number of queries and the amount of mana at the beginning of every fight.
i-th of each next q lines contains three numbers ki, ai and bi (1 ≤ ki ≤ 2, 1 ≤ ai, bi ≤ 106).
Using them you can restore queries this way: let j be the index of the last query of second type with positive answer (j = 0 if there were none of these).
* If ki = 1, then character learns spell with x = (ai + j) mod 106 + 1, y = (bi + j) mod 106 + 1.
* If ki = 2, then you have to determine if Vova is able to win the fight against monster with t = (ai + j) mod 106 + 1, h = (bi + j) mod 106 + 1.
Output
For every query of second type print YES if Vova is able to win the fight with corresponding monster and NO otherwise.
Example
Input
3 100
1 4 9
2 19 49
2 19 49
Output
YES
NO
Note
In first example Vova's character at first learns the spell with 5 damage and 10 mana cost per second. Next query is a fight with monster which can kill character in 20 seconds and has 50 health points. Vova kills it in 10 seconds (spending 100 mana). Next monster has 52 health, so Vova can't deal that much damage with only 100 mana.
|
instruction
| 0
| 450
| 2
| 900
|
Tags: data structures, geometry
Correct Solution:
```
#!/usr/bin/env python3
# solution after hint
# (instead of best hit/mana spell store convex hull of spells)
# O(n^2) instead of O(n log n)
[q, m] = map(int, input().strip().split())
qis = [tuple(map(int, input().strip().split())) for _ in range(q)]
mod = 10**6
j = 0
spell_chull = [(0, 0)] # lower hull _/
def is_right(xy0, xy1, xy):
(x0, y0) = xy0
(x1, y1) = xy1
(x, y) = xy
return (x0 - x) * (y1 - y) >= (x1 - x) * (y0 - y)
def in_chull(x, y):
i = 0
if x > spell_chull[-1][0]:
return False
while spell_chull[i][0] < x:
i += 1
if spell_chull[i][0] == x:
return spell_chull[i][1] <= y
else:
return is_right(spell_chull[i - 1], spell_chull[i], (x, y))
def add_spell(x, y):
global spell_chull
if in_chull(x, y):
return
i_left = 0
while i_left < len(spell_chull) - 1 and not is_right(spell_chull[i_left + 1], spell_chull[i_left], (x, y)):
i_left += 1
i_right = i_left + 1
while i_right < len(spell_chull) - 1 and is_right(spell_chull[i_right + 1], spell_chull[i_right], (x, y)):
i_right += 1
if i_right == len(spell_chull) - 1 and x >= spell_chull[-1][0]:
i_right += 1
spell_chull = spell_chull[:i_left + 1] + [(x, y)] + spell_chull[i_right:]
for i, qi in enumerate(qis):
(k, a, b) = qi
x = (a + j) % mod + 1
y = (b + j) % mod + 1
if k == 1:
add_spell(x, y)
else: #2
if in_chull(y / x, m / x):
print ('YES')
j = i + 1
else:
print ('NO')
```
|
output
| 1
| 450
| 2
| 901
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova plays a computer game known as Mages and Monsters. Vova's character is a mage. Though as he has just started, his character knows no spells.
Vova's character can learn new spells during the game. Every spell is characterized by two values xi and yi — damage per second and mana cost per second, respectively. Vova doesn't have to use a spell for an integer amount of seconds. More formally, if he uses a spell with damage x and mana cost y for z seconds, then he will deal x·z damage and spend y·z mana (no rounding). If there is no mana left (mana amount is set in the start of the game and it remains the same at the beginning of every fight), then character won't be able to use any spells. It is prohibited to use multiple spells simultaneously.
Also Vova can fight monsters. Every monster is characterized by two values tj and hj — monster kills Vova's character in tj seconds and has hj health points. Mana refills after every fight (or Vova's character revives with full mana reserve), so previous fights have no influence on further ones.
Vova's character kills a monster, if he deals hj damage to it in no more than tj seconds using his spells (it is allowed to use more than one spell in a fight) and spending no more mana than he had at the beginning of the fight. If monster's health becomes zero exactly in tj seconds (it means that the monster and Vova's character kill each other at the same time), then Vova wins the fight.
You have to write a program which can answer two types of queries:
* 1 x y — Vova's character learns new spell which deals x damage per second and costs y mana per second.
* 2 t h — Vova fights the monster which kills his character in t seconds and has h health points.
Note that queries are given in a different form. Also remember that Vova's character knows no spells at the beginning of the game.
For every query of second type you have to determine if Vova is able to win the fight with corresponding monster.
Input
The first line contains two integer numbers q and m (2 ≤ q ≤ 105, 1 ≤ m ≤ 1012) — the number of queries and the amount of mana at the beginning of every fight.
i-th of each next q lines contains three numbers ki, ai and bi (1 ≤ ki ≤ 2, 1 ≤ ai, bi ≤ 106).
Using them you can restore queries this way: let j be the index of the last query of second type with positive answer (j = 0 if there were none of these).
* If ki = 1, then character learns spell with x = (ai + j) mod 106 + 1, y = (bi + j) mod 106 + 1.
* If ki = 2, then you have to determine if Vova is able to win the fight against monster with t = (ai + j) mod 106 + 1, h = (bi + j) mod 106 + 1.
Output
For every query of second type print YES if Vova is able to win the fight with corresponding monster and NO otherwise.
Example
Input
3 100
1 4 9
2 19 49
2 19 49
Output
YES
NO
Note
In first example Vova's character at first learns the spell with 5 damage and 10 mana cost per second. Next query is a fight with monster which can kill character in 20 seconds and has 50 health points. Vova kills it in 10 seconds (spending 100 mana). Next monster has 52 health, so Vova can't deal that much damage with only 100 mana.
Submitted Solution:
```
#!/usr/bin/env python3
[q, m] = map(int, input().strip().split())
qis = [tuple(map(int, input().strip().split())) for _ in range(q)]
mod = 10**6
j = 0
(xb, yb) = (0, 1)
for i, qi in enumerate(qis):
(k, a, b) = qi
x = (a + j) % mod + 1
y = (b + j) % mod + 1
if k == 1:
if x * yb > y * xb:
(xb, yb) = (x, y)
else: #2
if min(m, x * yb) * xb >= y * yb:
print ('YES')
j = i + 1
else:
print ('NO')
```
|
instruction
| 0
| 451
| 2
| 902
|
No
|
output
| 1
| 451
| 2
| 903
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova plays a computer game known as Mages and Monsters. Vova's character is a mage. Though as he has just started, his character knows no spells.
Vova's character can learn new spells during the game. Every spell is characterized by two values xi and yi — damage per second and mana cost per second, respectively. Vova doesn't have to use a spell for an integer amount of seconds. More formally, if he uses a spell with damage x and mana cost y for z seconds, then he will deal x·z damage and spend y·z mana (no rounding). If there is no mana left (mana amount is set in the start of the game and it remains the same at the beginning of every fight), then character won't be able to use any spells. It is prohibited to use multiple spells simultaneously.
Also Vova can fight monsters. Every monster is characterized by two values tj and hj — monster kills Vova's character in tj seconds and has hj health points. Mana refills after every fight (or Vova's character revives with full mana reserve), so previous fights have no influence on further ones.
Vova's character kills a monster, if he deals hj damage to it in no more than tj seconds using his spells (it is allowed to use more than one spell in a fight) and spending no more mana than he had at the beginning of the fight. If monster's health becomes zero exactly in tj seconds (it means that the monster and Vova's character kill each other at the same time), then Vova wins the fight.
You have to write a program which can answer two types of queries:
* 1 x y — Vova's character learns new spell which deals x damage per second and costs y mana per second.
* 2 t h — Vova fights the monster which kills his character in t seconds and has h health points.
Note that queries are given in a different form. Also remember that Vova's character knows no spells at the beginning of the game.
For every query of second type you have to determine if Vova is able to win the fight with corresponding monster.
Input
The first line contains two integer numbers q and m (2 ≤ q ≤ 105, 1 ≤ m ≤ 1012) — the number of queries and the amount of mana at the beginning of every fight.
i-th of each next q lines contains three numbers ki, ai and bi (1 ≤ ki ≤ 2, 1 ≤ ai, bi ≤ 106).
Using them you can restore queries this way: let j be the index of the last query of second type with positive answer (j = 0 if there were none of these).
* If ki = 1, then character learns spell with x = (ai + j) mod 106 + 1, y = (bi + j) mod 106 + 1.
* If ki = 2, then you have to determine if Vova is able to win the fight against monster with t = (ai + j) mod 106 + 1, h = (bi + j) mod 106 + 1.
Output
For every query of second type print YES if Vova is able to win the fight with corresponding monster and NO otherwise.
Example
Input
3 100
1 4 9
2 19 49
2 19 49
Output
YES
NO
Note
In first example Vova's character at first learns the spell with 5 damage and 10 mana cost per second. Next query is a fight with monster which can kill character in 20 seconds and has 50 health points. Vova kills it in 10 seconds (spending 100 mana). Next monster has 52 health, so Vova can't deal that much damage with only 100 mana.
Submitted Solution:
```
#site : https://codeforces.com/contest/792/problem/F
#Spells characterized by 2 values : x[i] and y[i]
#Doesn't have to use spell for int(x) amounts of seconds
#x = damage , y = mana cost , z = seconds
#deals x * z damage spends y * z mana
#If no mana is left , canUseSpell = False
#Can fight monsters : t[j] and h[j] . t = time to kill vova's char , h = monster's hp
#After fight , mana is refilled
#if dealt h[j] damage no more than t[j] seconds using his spells , monster j dies and vova's mana refills (and if monster's health becomes exactly 0 in t[j] , the same thing happens)
#Program :
#Vova learns a new spell dealing x dps and y mps (mana per second(s) )
#Fights a monster which kills him in t seconds and has h hp
#(Vova doesn't know any spell at the beginning)
#What to do ?
#You have to determine if vova's able to win the fight or no
#Input :
#First line :
#q -> the number of queries , m -> amount of mana at the beginning of fight
#2 =< q <= 10 ** 5 , 1 <= m <= 10 ** 12
#then for i=1 in range(1, q) do this :
#input 3 int values : 1 <= k[i] <= 2 , 1 <= a[i] and b[i] <= 10 ** 6
#k is basically the action you want to do . either 1 or 2 . 1 means character learns a spell with x (dps) = (a[i] + j (the last monster you fought with) ) % (10 ** 6) + 1 <- for limiting it to be less than 10 ** 6
#and 2 means if character is able to win against the monster or no (output = "YES" or "NO") with time to kill of t = (a[i] + j) % (10 ** 6) + 1 and hp of h = (b[i] + j) % (10 ** 6) + 1
#inputs must be in input file in the same directory of this file
#Start of code :
x = []
y = []
killedMonster = False
j = 0
t, h = 0,0
q, m = 0, 0
def get_input():
global q, m
k, a, b = [],[],[]
values = input()
q, m = int(values.split(" ")[0]), int(values.split(" ")[1])
for i in range(0,q):
inp = input()
k.append(int(inp.split(" ")[0]))
a.append(int(inp.split(" ")[1]))
b.append(int(inp.split(" ")[2]) % 10 ** 6)
value = [k,a,b]
return value
k, a, b = get_input()
for i in range(q):
if k[i] == 1:
x.append((a[i] + j) % 10 ** 6 + 1)
y.append((b[i] + j) % 10 ** 6 + 1)
elif k[i] == 2:
t = (a[i] + j) % 10 ** 6 + 1
h = (b[i] + j) % 10 ** 6 + 1
for chosen in range(0,len(x)):
if x[chosen] * t >= h and y[chosen] * t <= m * 2:
print("YES")
killedMonster = True
break
if not killedMonster:
print("NO")
else:
killedMonster = False
j += 1
```
|
instruction
| 0
| 452
| 2
| 904
|
No
|
output
| 1
| 452
| 2
| 905
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova plays a computer game known as Mages and Monsters. Vova's character is a mage. Though as he has just started, his character knows no spells.
Vova's character can learn new spells during the game. Every spell is characterized by two values xi and yi — damage per second and mana cost per second, respectively. Vova doesn't have to use a spell for an integer amount of seconds. More formally, if he uses a spell with damage x and mana cost y for z seconds, then he will deal x·z damage and spend y·z mana (no rounding). If there is no mana left (mana amount is set in the start of the game and it remains the same at the beginning of every fight), then character won't be able to use any spells. It is prohibited to use multiple spells simultaneously.
Also Vova can fight monsters. Every monster is characterized by two values tj and hj — monster kills Vova's character in tj seconds and has hj health points. Mana refills after every fight (or Vova's character revives with full mana reserve), so previous fights have no influence on further ones.
Vova's character kills a monster, if he deals hj damage to it in no more than tj seconds using his spells (it is allowed to use more than one spell in a fight) and spending no more mana than he had at the beginning of the fight. If monster's health becomes zero exactly in tj seconds (it means that the monster and Vova's character kill each other at the same time), then Vova wins the fight.
You have to write a program which can answer two types of queries:
* 1 x y — Vova's character learns new spell which deals x damage per second and costs y mana per second.
* 2 t h — Vova fights the monster which kills his character in t seconds and has h health points.
Note that queries are given in a different form. Also remember that Vova's character knows no spells at the beginning of the game.
For every query of second type you have to determine if Vova is able to win the fight with corresponding monster.
Input
The first line contains two integer numbers q and m (2 ≤ q ≤ 105, 1 ≤ m ≤ 1012) — the number of queries and the amount of mana at the beginning of every fight.
i-th of each next q lines contains three numbers ki, ai and bi (1 ≤ ki ≤ 2, 1 ≤ ai, bi ≤ 106).
Using them you can restore queries this way: let j be the index of the last query of second type with positive answer (j = 0 if there were none of these).
* If ki = 1, then character learns spell with x = (ai + j) mod 106 + 1, y = (bi + j) mod 106 + 1.
* If ki = 2, then you have to determine if Vova is able to win the fight against monster with t = (ai + j) mod 106 + 1, h = (bi + j) mod 106 + 1.
Output
For every query of second type print YES if Vova is able to win the fight with corresponding monster and NO otherwise.
Example
Input
3 100
1 4 9
2 19 49
2 19 49
Output
YES
NO
Note
In first example Vova's character at first learns the spell with 5 damage and 10 mana cost per second. Next query is a fight with monster which can kill character in 20 seconds and has 50 health points. Vova kills it in 10 seconds (spending 100 mana). Next monster has 52 health, so Vova can't deal that much damage with only 100 mana.
Submitted Solution:
```
#site : https://codeforces.com/contest/792/problem/F
#Spells characterized by 2 values : x[i] and y[i]
#Doesn't have to use spell for int(x) amounts of seconds
#x = damage , y = mana cost , z = seconds
#deals x * z damage spends y * z mana
#If no mana is left , canUseSpell = False
#Can fight monsters : t[j] and h[j] . t = time to kill vova's char , h = monster's hp
#After fight , mana is refilled
#if dealt h[j] damage no more than t[j] seconds using his spells , monster j dies and vova's mana refills (and if monster's health becomes exactly 0 in t[j] , the same thing happens)
#Program :
#Vova learns a new spell dealing x dps and y mps (mana per second(s) )
#Fights a monster which kills him in t seconds and has h hp
#(Vova doesn't know any spell at the beginning)
#What to do ?
#You have to determine if vova's able to win the fight or no
#Input :
#First line :
#q -> the number of queries , m -> amount of mana at the beginning of fight
#2 =< q <= 10 ** 5 , 1 <= m <= 10 ** 12
#then for i=1 in range(1, q) do this :
#input 3 int values : 1 <= k[i] <= 2 , 1 <= a[i] and b[i] <= 10 ** 6
#k is basically the action you want to do . either 1 or 2 . 1 means character learns a spell with x (dps) = (a[i] + j (the last monster you fought with) ) % (10 ** 6) + 1 <- for limiting it to be less than 10 ** 6
#and 2 means if character is able to win against the monster or no (output = "YES" or "NO") with time to kill of t = (a[i] + j) % (10 ** 6) + 1 and hp of h = (b[i] + j) % (10 ** 6) + 1
#inputs must be in input file in the same directory of this file
#Start of code :
x = 0
y = 0
j = 0
t, h = 0,0
q, m = 0, 0
def get_input():
global q, m
k, a, b = [],[],[]
values = input()
q, m = int(values.split(" ")[0]), int(values.split(" ")[1])
for i in range(0,q):
inp = input()
k.append(int(inp.split(" ")[0]))
a.append(int(inp.split(" ")[1]))
b.append(int(inp.split(" ")[2]) % 10 ** 6)
value = [k,a,b]
return value
k, a, b = get_input()
for i in range(q):
if k[i] == 1:
x = (a[i] + j) % 10 ** 6 + 1
y = (b[i] + j) % 10 ** 6 + 1
elif k[i] == 2:
t = (a[i] + j) % 10 ** 6 + 1
h = (b[i] + j) % 10 ** 6 + 1
j += 1
if x * t >= h and y * t <= m * 2:
print("YES")
else:
print("NO")
```
|
instruction
| 0
| 453
| 2
| 906
|
No
|
output
| 1
| 453
| 2
| 907
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova plays a computer game known as Mages and Monsters. Vova's character is a mage. Though as he has just started, his character knows no spells.
Vova's character can learn new spells during the game. Every spell is characterized by two values xi and yi — damage per second and mana cost per second, respectively. Vova doesn't have to use a spell for an integer amount of seconds. More formally, if he uses a spell with damage x and mana cost y for z seconds, then he will deal x·z damage and spend y·z mana (no rounding). If there is no mana left (mana amount is set in the start of the game and it remains the same at the beginning of every fight), then character won't be able to use any spells. It is prohibited to use multiple spells simultaneously.
Also Vova can fight monsters. Every monster is characterized by two values tj and hj — monster kills Vova's character in tj seconds and has hj health points. Mana refills after every fight (or Vova's character revives with full mana reserve), so previous fights have no influence on further ones.
Vova's character kills a monster, if he deals hj damage to it in no more than tj seconds using his spells (it is allowed to use more than one spell in a fight) and spending no more mana than he had at the beginning of the fight. If monster's health becomes zero exactly in tj seconds (it means that the monster and Vova's character kill each other at the same time), then Vova wins the fight.
You have to write a program which can answer two types of queries:
* 1 x y — Vova's character learns new spell which deals x damage per second and costs y mana per second.
* 2 t h — Vova fights the monster which kills his character in t seconds and has h health points.
Note that queries are given in a different form. Also remember that Vova's character knows no spells at the beginning of the game.
For every query of second type you have to determine if Vova is able to win the fight with corresponding monster.
Input
The first line contains two integer numbers q and m (2 ≤ q ≤ 105, 1 ≤ m ≤ 1012) — the number of queries and the amount of mana at the beginning of every fight.
i-th of each next q lines contains three numbers ki, ai and bi (1 ≤ ki ≤ 2, 1 ≤ ai, bi ≤ 106).
Using them you can restore queries this way: let j be the index of the last query of second type with positive answer (j = 0 if there were none of these).
* If ki = 1, then character learns spell with x = (ai + j) mod 106 + 1, y = (bi + j) mod 106 + 1.
* If ki = 2, then you have to determine if Vova is able to win the fight against monster with t = (ai + j) mod 106 + 1, h = (bi + j) mod 106 + 1.
Output
For every query of second type print YES if Vova is able to win the fight with corresponding monster and NO otherwise.
Example
Input
3 100
1 4 9
2 19 49
2 19 49
Output
YES
NO
Note
In first example Vova's character at first learns the spell with 5 damage and 10 mana cost per second. Next query is a fight with monster which can kill character in 20 seconds and has 50 health points. Vova kills it in 10 seconds (spending 100 mana). Next monster has 52 health, so Vova can't deal that much damage with only 100 mana.
Submitted Solution:
```
#site : https://codeforces.com/contest/792/problem/F
#Spells characterized by 2 values : x[i] and y[i]
#Doesn't have to use spell for int(x) amounts of seconds
#x = damage , y = mana cost , z = seconds
#deals x * z damage spends y * z mana
#If no mana is left , canUseSpell = False
#Can fight monsters : t[j] and h[j] . t = time to kill vova's char , h = monster's hp
#After fight , mana is refilled
#if dealt h[j] damage no more than t[j] seconds using his spells , monster j dies and vova's mana refills (and if monster's health becomes exactly 0 in t[j] , the same thing happens)
#Program :
#Vova learns a new spell dealing x dps and y mps (mana per second(s) )
#Fights a monster which kills him in t seconds and has h hp
#(Vova doesn't know any spell at the beginning)
#What to do ?
#You have to determine if vova's able to win the fight or no
#Input :
#First line :
#q -> the number of queries , m -> amount of mana at the beginning of fight
#2 =< q <= 10 ** 5 , 1 <= m <= 10 ** 12
#then for i=1 in range(1, q) do this :
#input 3 int values : 1 <= k[i] <= 2 , 1 <= a[i] and b[i] <= 10 ** 6
#k is basically the action you want to do . either 1 or 2 . 1 means character learns a spell with x (dps) = (a[i] + j (the last monster you fought with) ) % (10 ** 6) + 1 <- for limiting it to be less than 10 ** 6
#and 2 means if character is able to win against the monster or no (output = "YES" or "NO") with time to kill of t = (a[i] + j) % (10 ** 6) + 1 and hp of h = (b[i] + j) % (10 ** 6) + 1
#inputs must be in input file in the same directory of this file
#Start of code :
x = []
y = []
killedMonster = False
j = 0
t, h = 0,0
q, m = 0, 0
def get_input():
global q, m
k, a, b = [],[],[]
values = input()
q, m = int(values.split(" ")[0]), int(values.split(" ")[1])
for i in range(0,q):
inp = input()
k.append(int(inp.split(" ")[0]))
a.append(int(inp.split(" ")[1]))
b.append(int(inp.split(" ")[2]) % 10 ** 6)
value = [k,a,b]
return value
k, a, b = get_input()
for i in range(q):
if k[i] == 1:
x.append((a[i] + j) % 10 ** 6 + 1)
y.append((b[i] + j) % 10 ** 6 + 1)
elif k[i] == 2:
j += 1
t = (a[i] + j) % 10 ** 6 + 1
h = (b[i] + j) % 10 ** 6 + 1
for chosen in range(0,len(x)):
if x[chosen] * t >= h and y[chosen] * t <= m * 2:
print("YES")
killedMonster = True
break
if not killedMonster:
print("NO")
else:
killedMonster = False
```
|
instruction
| 0
| 454
| 2
| 908
|
No
|
output
| 1
| 454
| 2
| 909
|
Provide a correct Python 3 solution for this coding contest problem.
Brave Ponta and his best friend, Brave Gonta, have come to Luida's bar in search of friends to embark on an epic adventure. There are many warriors, monks and wizards in the tavern who are itching to go on an adventure.
Gonta, who is kind-hearted, cared for Ponta and said, "You can choose your friends first."
On the other hand, don't worry about Ponta and Gonta. "No, you can choose first."
We continued to give in to each other, and finally Luida proposed: "Then, I'll divide the n registrants here with this" party division machine "so that the total fighting power of each party is as even as possible."
The task given to you is to create a program that is built into the partying machine.
This program inputs n integers and outputs the minimum difference between the total value of the integers contained in A and the total value of the integers contained in B when they are divided into two groups A and B. Must be.
Thanks to this machine, Ponta and Gonta got along well and went on an epic adventure ...
Input
Multiple datasets are given as input. Each dataset is given in the following format:
n (number of registrants: integer)
a1 a2 ... an (combat power of each registrant: blank-separated integer)
n is 20 or less, and each registrant's combat power does not exceed 1 million.
When n is 0, it is the end of input.
Output
Print the minimum value on one line for each dataset.
Example
Input
5
1 2 3 4 5
4
2 3 5 7
0
Output
1
1
|
instruction
| 0
| 730
| 2
| 1,460
|
"Correct Solution:
```
def main():
while True:
n = int(input())
if n == 0:
break
alst = list(map(int, input().split()))
s = sum(alst)
alst = [a * 2 for a in alst]
lst = [-s]
for a in alst:
lst.extend([i + a for i in lst])
print(min(map(abs, lst)))
main()
```
|
output
| 1
| 730
| 2
| 1,461
|
Provide a correct Python 3 solution for this coding contest problem.
Brave Ponta and his best friend, Brave Gonta, have come to Luida's bar in search of friends to embark on an epic adventure. There are many warriors, monks and wizards in the tavern who are itching to go on an adventure.
Gonta, who is kind-hearted, cared for Ponta and said, "You can choose your friends first."
On the other hand, don't worry about Ponta and Gonta. "No, you can choose first."
We continued to give in to each other, and finally Luida proposed: "Then, I'll divide the n registrants here with this" party division machine "so that the total fighting power of each party is as even as possible."
The task given to you is to create a program that is built into the partying machine.
This program inputs n integers and outputs the minimum difference between the total value of the integers contained in A and the total value of the integers contained in B when they are divided into two groups A and B. Must be.
Thanks to this machine, Ponta and Gonta got along well and went on an epic adventure ...
Input
Multiple datasets are given as input. Each dataset is given in the following format:
n (number of registrants: integer)
a1 a2 ... an (combat power of each registrant: blank-separated integer)
n is 20 or less, and each registrant's combat power does not exceed 1 million.
When n is 0, it is the end of input.
Output
Print the minimum value on one line for each dataset.
Example
Input
5
1 2 3 4 5
4
2 3 5 7
0
Output
1
1
|
instruction
| 0
| 731
| 2
| 1,462
|
"Correct Solution:
```
while True:
n = int(input())
if n == 0:
break
a = list(map(int, input().split()))
b = sum(a)
ans = b >> 1
if ans in a:
print(b - 2*ans)
continue
c = [v for v in a if v < ans]
s , f, q, qlen = set(), True, [0], 1
for v in c:
i, k = 0, qlen
while k:
v2 = v + q[i]
k, i = k-1, i+1
if v2 == ans:
f = False
break
if v2 < ans and v2 not in s:
s.add(v2)
q.append(v2)
qlen += 1
if f:
while True:
ans -= 1
if ans == 0:
break
if ans in s:
break
print(b - 2 * ans)
```
|
output
| 1
| 731
| 2
| 1,463
|
Provide a correct Python 3 solution for this coding contest problem.
Brave Ponta and his best friend, Brave Gonta, have come to Luida's bar in search of friends to embark on an epic adventure. There are many warriors, monks and wizards in the tavern who are itching to go on an adventure.
Gonta, who is kind-hearted, cared for Ponta and said, "You can choose your friends first."
On the other hand, don't worry about Ponta and Gonta. "No, you can choose first."
We continued to give in to each other, and finally Luida proposed: "Then, I'll divide the n registrants here with this" party division machine "so that the total fighting power of each party is as even as possible."
The task given to you is to create a program that is built into the partying machine.
This program inputs n integers and outputs the minimum difference between the total value of the integers contained in A and the total value of the integers contained in B when they are divided into two groups A and B. Must be.
Thanks to this machine, Ponta and Gonta got along well and went on an epic adventure ...
Input
Multiple datasets are given as input. Each dataset is given in the following format:
n (number of registrants: integer)
a1 a2 ... an (combat power of each registrant: blank-separated integer)
n is 20 or less, and each registrant's combat power does not exceed 1 million.
When n is 0, it is the end of input.
Output
Print the minimum value on one line for each dataset.
Example
Input
5
1 2 3 4 5
4
2 3 5 7
0
Output
1
1
|
instruction
| 0
| 732
| 2
| 1,464
|
"Correct Solution:
```
# AOJ 1045: Split Up!
# Python3 2018.7.6 bal4u
while True:
n = int(input())
if n == 0: break
t = list(map(int, input().split()))
s = sum(t)
ans = s >> 1
if ans in t:
print(s - 2*ans)
continue
a = [v for v in t if v < ans]
S, f, Q, qlen = set(), True, [0], 1
for v in a:
i, k = 0, qlen
while k:
v2 = v + Q[i]
k, i = k-1, i+1
if v2 == ans:
f = False
break
if v2 < ans and v2 not in S:
S.add(v2)
Q.append(v2)
qlen += 1
if f:
while True:
ans -= 1
if ans == 0: break
if ans in S: break;
print(s - 2*ans)
```
|
output
| 1
| 732
| 2
| 1,465
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Brave Ponta and his best friend, Brave Gonta, have come to Luida's bar in search of friends to embark on an epic adventure. There are many warriors, monks and wizards in the tavern who are itching to go on an adventure.
Gonta, who is kind-hearted, cared for Ponta and said, "You can choose your friends first."
On the other hand, don't worry about Ponta and Gonta. "No, you can choose first."
We continued to give in to each other, and finally Luida proposed: "Then, I'll divide the n registrants here with this" party division machine "so that the total fighting power of each party is as even as possible."
The task given to you is to create a program that is built into the partying machine.
This program inputs n integers and outputs the minimum difference between the total value of the integers contained in A and the total value of the integers contained in B when they are divided into two groups A and B. Must be.
Thanks to this machine, Ponta and Gonta got along well and went on an epic adventure ...
Input
Multiple datasets are given as input. Each dataset is given in the following format:
n (number of registrants: integer)
a1 a2 ... an (combat power of each registrant: blank-separated integer)
n is 20 or less, and each registrant's combat power does not exceed 1 million.
When n is 0, it is the end of input.
Output
Print the minimum value on one line for each dataset.
Example
Input
5
1 2 3 4 5
4
2 3 5 7
0
Output
1
1
Submitted Solution:
```
# AOJ 1045: Split Up!
# Python3 2018.7.6 bal4u
while True:
n = int(input())
if n == 0: break
t = list(map(int, input().split()))
s = sum(t)
ans = s >> 1
a, f = [], True
for v in t:
if v == ans:
f = False
break
if v < ans: a.append(v)
if f:
S, Q = set(), [0]
for v in a:
while Q:
v2 = v + Q.pop(0)
if v2 == ans:
f = False
break
if v2 < ans and v2 not in S:
S.add(v2)
Q.append(v2)
if f:
while ans > 1:
ans -= 1
if ans in S: break;
print(s - 2*ans)
```
|
instruction
| 0
| 733
| 2
| 1,466
|
No
|
output
| 1
| 733
| 2
| 1,467
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Brave Ponta and his best friend, Brave Gonta, have come to Luida's bar in search of friends to embark on an epic adventure. There are many warriors, monks and wizards in the tavern who are itching to go on an adventure.
Gonta, who is kind-hearted, cared for Ponta and said, "You can choose your friends first."
On the other hand, don't worry about Ponta and Gonta. "No, you can choose first."
We continued to give in to each other, and finally Luida proposed: "Then, I'll divide the n registrants here with this" party division machine "so that the total fighting power of each party is as even as possible."
The task given to you is to create a program that is built into the partying machine.
This program inputs n integers and outputs the minimum difference between the total value of the integers contained in A and the total value of the integers contained in B when they are divided into two groups A and B. Must be.
Thanks to this machine, Ponta and Gonta got along well and went on an epic adventure ...
Input
Multiple datasets are given as input. Each dataset is given in the following format:
n (number of registrants: integer)
a1 a2 ... an (combat power of each registrant: blank-separated integer)
n is 20 or less, and each registrant's combat power does not exceed 1 million.
When n is 0, it is the end of input.
Output
Print the minimum value on one line for each dataset.
Example
Input
5
1 2 3 4 5
4
2 3 5 7
0
Output
1
1
Submitted Solution:
```
while 1:
n=int(input())
if n==0:break
m=sorted(map(int,input().split()),reverse=1)
a=b=0
for i in m:
if a>b:b+=i
else: a+=i
print(abs(a-b))
```
|
instruction
| 0
| 734
| 2
| 1,468
|
No
|
output
| 1
| 734
| 2
| 1,469
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Brave Ponta and his best friend, Brave Gonta, have come to Luida's bar in search of friends to embark on an epic adventure. There are many warriors, monks and wizards in the tavern who are itching to go on an adventure.
Gonta, who is kind-hearted, cared for Ponta and said, "You can choose your friends first."
On the other hand, don't worry about Ponta and Gonta. "No, you can choose first."
We continued to give in to each other, and finally Luida proposed: "Then, I'll divide the n registrants here with this" party division machine "so that the total fighting power of each party is as even as possible."
The task given to you is to create a program that is built into the partying machine.
This program inputs n integers and outputs the minimum difference between the total value of the integers contained in A and the total value of the integers contained in B when they are divided into two groups A and B. Must be.
Thanks to this machine, Ponta and Gonta got along well and went on an epic adventure ...
Input
Multiple datasets are given as input. Each dataset is given in the following format:
n (number of registrants: integer)
a1 a2 ... an (combat power of each registrant: blank-separated integer)
n is 20 or less, and each registrant's combat power does not exceed 1 million.
When n is 0, it is the end of input.
Output
Print the minimum value on one line for each dataset.
Example
Input
5
1 2 3 4 5
4
2 3 5 7
0
Output
1
1
Submitted Solution:
```
while 1:
n=int(input())
if n==0:break
m=sorted(map(int,input().split()),reverse=1)
a=b=0
print(m)
for i in m:
if a>b:b+=i
else: a+=i
print(abs(a-b))
```
|
instruction
| 0
| 735
| 2
| 1,470
|
No
|
output
| 1
| 735
| 2
| 1,471
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Brave Ponta and his best friend, Brave Gonta, have come to Luida's bar in search of friends to embark on an epic adventure. There are many warriors, monks and wizards in the tavern who are itching to go on an adventure.
Gonta, who is kind-hearted, cared for Ponta and said, "You can choose your friends first."
On the other hand, don't worry about Ponta and Gonta. "No, you can choose first."
We continued to give in to each other, and finally Luida proposed: "Then, I'll divide the n registrants here with this" party division machine "so that the total fighting power of each party is as even as possible."
The task given to you is to create a program that is built into the partying machine.
This program inputs n integers and outputs the minimum difference between the total value of the integers contained in A and the total value of the integers contained in B when they are divided into two groups A and B. Must be.
Thanks to this machine, Ponta and Gonta got along well and went on an epic adventure ...
Input
Multiple datasets are given as input. Each dataset is given in the following format:
n (number of registrants: integer)
a1 a2 ... an (combat power of each registrant: blank-separated integer)
n is 20 or less, and each registrant's combat power does not exceed 1 million.
When n is 0, it is the end of input.
Output
Print the minimum value on one line for each dataset.
Example
Input
5
1 2 3 4 5
4
2 3 5 7
0
Output
1
1
Submitted Solution:
```
m=[0]*20
d=1<<20
def f(a, b, c, n,):
global d
if c==n:d=min(d,abs(a-b));return
f(a+m[c],b,c+1,n)
f(a,b+m[c],c+1,n)
return (d)
while 1:
n=int(input())
if n==0:break
m=sorted(map(int,input().split()),reverse=1)
print(f(0,0,0,n))
```
|
instruction
| 0
| 736
| 2
| 1,472
|
No
|
output
| 1
| 736
| 2
| 1,473
|
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a colony of villains with several holes aligned in a row, where each hole contains exactly one villain.
Each colony arrangement can be expressed as a string of even length, where the i-th character of the string represents the type of villain in the i-th hole.
Iron Man can destroy a colony only if the colony arrangement is such that all villains of a certain type either live in the first half of the colony or in the second half of the colony.
His assistant Jarvis has a special power. It can swap villains of any two holes, i.e. swap any two characters in the string; he can do this operation any number of times.
Now Iron Man asks Jarvis q questions. In each question, he gives Jarvis two numbers x and y. Jarvis has to tell Iron Man the number of distinct colony arrangements he can create from the original one using his powers such that all villains having the same type as those originally living in x-th hole or y-th hole live in the same half and the Iron Man can destroy that colony arrangement.
Two colony arrangements are considered to be different if there exists a hole such that different types of villains are present in that hole in the arrangements.
Input
The first line contains a string s (2 ≤ |s| ≤ 10^{5}), representing the initial colony arrangement. String s can have both lowercase and uppercase English letters and its length is even.
The second line contains a single integer q (1 ≤ q ≤ 10^{5}) — the number of questions.
The i-th of the next q lines contains two integers x_i and y_i (1 ≤ x_i, y_i ≤ |s|, x_i ≠ y_i) — the two numbers given to the Jarvis for the i-th question.
Output
For each question output the number of arrangements possible modulo 10^9+7.
Examples
Input
abba
2
1 4
1 2
Output
2
0
Input
AAaa
2
1 2
1 3
Output
2
0
Input
abcd
1
1 3
Output
8
Note
Consider the first example. For the first question, the possible arrangements are "aabb" and "bbaa", and for the second question, index 1 contains 'a' and index 2 contains 'b' and there is no valid arrangement in which all 'a' and 'b' are in the same half.
|
instruction
| 0
| 847
| 2
| 1,694
|
Tags: combinatorics, dp, math
Correct Solution:
```
from sys import stdin
MOD = 1000000007
s = stdin.readline().strip()
n = len(s)
buc = [0] * 101
fac = [0] * (n + 1)
inv = [0] * (n + 1)
dp = [0] * (n + 1)
# temp_dp = [0] * (n+1)
ans = [[0] * 55 for _ in range(55)]
def find(c: 'str') -> 'int':
if 'A' <= c <= 'Z':
return ord(c) - ord('A') + 26
else:
return ord(c) - ord('a')
# c = Counter(s)
# # store frequency
# for k in c.keys():
# buc[find(k)] = c[k]
for i in s:
buc[find(i)] += 1
# compute factorial and inv
fac[0] = 1
for i in range(1, n + 1):
fac[i] = (fac[i - 1] * i) % MOD
inv[n] = pow(fac[n], MOD - 2, MOD)
for i in range(n - 1, -1, -1):
inv[i] = (inv[i + 1] * (i + 1)) % MOD
num = pow(fac[n // 2], 2, MOD)
for i in range(0, 52):
num = (num * inv[buc[i]]) % MOD
dp[0] = 1
for i in range(0, 52):
if not buc[i]:
continue
for j in range(n, buc[i] - 1, -1):
dp[j] += dp[j - buc[i]]
if dp[j] >= MOD:
dp[j] -= MOD
for i in range(52):
ans[i][i] = dp[n // 2]
for i in range(52):
if not buc[i]:
continue
temp_dp = dp.copy()
for k in range(buc[i], n + 1):
temp_dp[k] -= temp_dp[k - buc[i]]
if temp_dp[k] < 0:
temp_dp[k] += MOD
for j in range(i + 1, 52):
if not buc[j]:
continue
for k in range(buc[j], n + 1):
temp_dp[k] -= temp_dp[k - buc[j]]
if temp_dp[k] < 0:
temp_dp[k] += MOD
ans[i][j] = (2 * temp_dp[n // 2]) % MOD
for k in range(n, buc[j] - 1, -1):
temp_dp[k] += temp_dp[k - buc[j]]
if temp_dp[k] >= MOD:
temp_dp[k] -= MOD
q = int(input())
l = stdin.read().splitlines()
for i in l:
x, y = map(int, i.split())
l, r = find(s[x - 1]), find(s[y - 1])
if l > r:
l, r = r, l
print(num * ans[l][r] % MOD)
```
|
output
| 1
| 847
| 2
| 1,695
|
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a colony of villains with several holes aligned in a row, where each hole contains exactly one villain.
Each colony arrangement can be expressed as a string of even length, where the i-th character of the string represents the type of villain in the i-th hole.
Iron Man can destroy a colony only if the colony arrangement is such that all villains of a certain type either live in the first half of the colony or in the second half of the colony.
His assistant Jarvis has a special power. It can swap villains of any two holes, i.e. swap any two characters in the string; he can do this operation any number of times.
Now Iron Man asks Jarvis q questions. In each question, he gives Jarvis two numbers x and y. Jarvis has to tell Iron Man the number of distinct colony arrangements he can create from the original one using his powers such that all villains having the same type as those originally living in x-th hole or y-th hole live in the same half and the Iron Man can destroy that colony arrangement.
Two colony arrangements are considered to be different if there exists a hole such that different types of villains are present in that hole in the arrangements.
Input
The first line contains a string s (2 ≤ |s| ≤ 10^{5}), representing the initial colony arrangement. String s can have both lowercase and uppercase English letters and its length is even.
The second line contains a single integer q (1 ≤ q ≤ 10^{5}) — the number of questions.
The i-th of the next q lines contains two integers x_i and y_i (1 ≤ x_i, y_i ≤ |s|, x_i ≠ y_i) — the two numbers given to the Jarvis for the i-th question.
Output
For each question output the number of arrangements possible modulo 10^9+7.
Examples
Input
abba
2
1 4
1 2
Output
2
0
Input
AAaa
2
1 2
1 3
Output
2
0
Input
abcd
1
1 3
Output
8
Note
Consider the first example. For the first question, the possible arrangements are "aabb" and "bbaa", and for the second question, index 1 contains 'a' and index 2 contains 'b' and there is no valid arrangement in which all 'a' and 'b' are in the same half.
|
instruction
| 0
| 848
| 2
| 1,696
|
Tags: combinatorics, dp, math
Correct Solution:
```
from sys import stdin
MOD = 1000000007
s = stdin.readline().strip()
n = len(s)
buc = [0] * 101
fac = [0] * (n + 1)
inv = [0] * (n + 1)
dp = [0] * (n + 1)
# temp_dp = [0] * (n+1)
ans = [[0] * 55 for _ in range(55)]
def find(c: 'str') -> 'int':
if 'A' <= c <= 'Z':
return ord(c) - ord('A') + 26
else:
return ord(c) - ord('a')
def add(a: 'int', b: 'int') -> 'int':
a += b
if a >= MOD:
a -= MOD
return a
def sub(a: 'int', b: 'int') -> 'int':
a -= b
if a < 0:
a += MOD
return a
# c = Counter(s)
# # store frequency
# for k in c.keys():
# buc[find(k)] = c[k]
for i in s:
buc[find(i)] += 1 # naive count is fater than counter
# compute factorial and inv
fac[0] = 1
for i in range(1, n + 1):
fac[i] = (fac[i - 1] * i) % MOD
inv[n] = pow(fac[n], MOD - 2, MOD)
for i in range(n - 1, -1, -1):
inv[i] = (inv[i + 1] * (i + 1)) % MOD
num = pow(fac[n // 2], 2, MOD)
for i in range(0, 52):
num = (num * inv[buc[i]]) % MOD
dp[0] = 1
for i in range(0, 52):
if not buc[i]:
continue
for j in range(n, buc[i] - 1, -1):
dp[j] = add(dp[j], dp[j - buc[i]])
for i in range(52):
ans[i][i] = dp[n // 2]
for i in range(52):
if not buc[i]:
continue
temp_dp = dp.copy()
for k in range(buc[i], n + 1):
temp_dp[k] = sub(temp_dp[k], temp_dp[k - buc[i]])
for j in range(i + 1, 52):
if not buc[j]:
continue
for k in range(buc[j], n + 1):
temp_dp[k] = sub(temp_dp[k], temp_dp[k - buc[j]])
ans[i][j] = (2 * temp_dp[n // 2]) % MOD
for k in range(n, buc[j] - 1, -1):
temp_dp[k] = add(temp_dp[k], temp_dp[k - buc[j]])
q = int(input())
l = stdin.read().splitlines()
for i in l:
x, y = map(int, i.split())
l, r = find(s[x - 1]), find(s[y - 1])
if l > r:
l, r = r, l
print(num * ans[l][r] % MOD)
```
|
output
| 1
| 848
| 2
| 1,697
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a colony of villains with several holes aligned in a row, where each hole contains exactly one villain.
Each colony arrangement can be expressed as a string of even length, where the i-th character of the string represents the type of villain in the i-th hole.
Iron Man can destroy a colony only if the colony arrangement is such that all villains of a certain type either live in the first half of the colony or in the second half of the colony.
His assistant Jarvis has a special power. It can swap villains of any two holes, i.e. swap any two characters in the string; he can do this operation any number of times.
Now Iron Man asks Jarvis q questions. In each question, he gives Jarvis two numbers x and y. Jarvis has to tell Iron Man the number of distinct colony arrangements he can create from the original one using his powers such that all villains having the same type as those originally living in x-th hole or y-th hole live in the same half and the Iron Man can destroy that colony arrangement.
Two colony arrangements are considered to be different if there exists a hole such that different types of villains are present in that hole in the arrangements.
Input
The first line contains a string s (2 ≤ |s| ≤ 10^{5}), representing the initial colony arrangement. String s can have both lowercase and uppercase English letters and its length is even.
The second line contains a single integer q (1 ≤ q ≤ 10^{5}) — the number of questions.
The i-th of the next q lines contains two integers x_i and y_i (1 ≤ x_i, y_i ≤ |s|, x_i ≠ y_i) — the two numbers given to the Jarvis for the i-th question.
Output
For each question output the number of arrangements possible modulo 10^9+7.
Examples
Input
abba
2
1 4
1 2
Output
2
0
Input
AAaa
2
1 2
1 3
Output
2
0
Input
abcd
1
1 3
Output
8
Note
Consider the first example. For the first question, the possible arrangements are "aabb" and "bbaa", and for the second question, index 1 contains 'a' and index 2 contains 'b' and there is no valid arrangement in which all 'a' and 'b' are in the same half.
Submitted Solution:
```
from collections import Counter
s = input()
n = int(input())
c = Counter(s)
res = 0
#print(c)
def fact(x):
if x > 1:
return x*fact(x-1)
return x
for i in range(n):
x, y = [int(x)-1 for x in input().split(' ')]
if s[x] == s[y]:
if len(c) > 2:
res = 0
else:
res = len(c)*(len(c)-1)
elif c[s[x]] + c[s[y]] > len(s)//2:
res = 0
else:
res = fact(len(c))//2
print(res)
```
|
instruction
| 0
| 849
| 2
| 1,698
|
No
|
output
| 1
| 849
| 2
| 1,699
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a colony of villains with several holes aligned in a row, where each hole contains exactly one villain.
Each colony arrangement can be expressed as a string of even length, where the i-th character of the string represents the type of villain in the i-th hole.
Iron Man can destroy a colony only if the colony arrangement is such that all villains of a certain type either live in the first half of the colony or in the second half of the colony.
His assistant Jarvis has a special power. It can swap villains of any two holes, i.e. swap any two characters in the string; he can do this operation any number of times.
Now Iron Man asks Jarvis q questions. In each question, he gives Jarvis two numbers x and y. Jarvis has to tell Iron Man the number of distinct colony arrangements he can create from the original one using his powers such that all villains having the same type as those originally living in x-th hole or y-th hole live in the same half and the Iron Man can destroy that colony arrangement.
Two colony arrangements are considered to be different if there exists a hole such that different types of villains are present in that hole in the arrangements.
Input
The first line contains a string s (2 ≤ |s| ≤ 10^{5}), representing the initial colony arrangement. String s can have both lowercase and uppercase English letters and its length is even.
The second line contains a single integer q (1 ≤ q ≤ 10^{5}) — the number of questions.
The i-th of the next q lines contains two integers x_i and y_i (1 ≤ x_i, y_i ≤ |s|, x_i ≠ y_i) — the two numbers given to the Jarvis for the i-th question.
Output
For each question output the number of arrangements possible modulo 10^9+7.
Examples
Input
abba
2
1 4
1 2
Output
2
0
Input
AAaa
2
1 2
1 3
Output
2
0
Input
abcd
1
1 3
Output
8
Note
Consider the first example. For the first question, the possible arrangements are "aabb" and "bbaa", and for the second question, index 1 contains 'a' and index 2 contains 'b' and there is no valid arrangement in which all 'a' and 'b' are in the same half.
Submitted Solution:
```
from math import factorial
s = input()
n = len(s)
dic = {}
for i in s:
if i in dic:
dic[i] += 1
else:
dic[i] = 1
q = int(input())
for _ in range(q):
a, b = list(map(int, input().split()))
x, y = s[a-1], s[b-1]
ans = factorial(n//2)**2
for i in dic:
ans //= factorial(dic[i])
if dic[x] + dic[y] == n//2:
res = ans
else:
res = 0
for i in dic:
if i != x:
if i != y:
if dic[x] + dic[y] + dic[i] == n//2:
res += ans
print(res)
```
|
instruction
| 0
| 850
| 2
| 1,700
|
No
|
output
| 1
| 850
| 2
| 1,701
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a colony of villains with several holes aligned in a row, where each hole contains exactly one villain.
Each colony arrangement can be expressed as a string of even length, where the i-th character of the string represents the type of villain in the i-th hole.
Iron Man can destroy a colony only if the colony arrangement is such that all villains of a certain type either live in the first half of the colony or in the second half of the colony.
His assistant Jarvis has a special power. It can swap villains of any two holes, i.e. swap any two characters in the string; he can do this operation any number of times.
Now Iron Man asks Jarvis q questions. In each question, he gives Jarvis two numbers x and y. Jarvis has to tell Iron Man the number of distinct colony arrangements he can create from the original one using his powers such that all villains having the same type as those originally living in x-th hole or y-th hole live in the same half and the Iron Man can destroy that colony arrangement.
Two colony arrangements are considered to be different if there exists a hole such that different types of villains are present in that hole in the arrangements.
Input
The first line contains a string s (2 ≤ |s| ≤ 10^{5}), representing the initial colony arrangement. String s can have both lowercase and uppercase English letters and its length is even.
The second line contains a single integer q (1 ≤ q ≤ 10^{5}) — the number of questions.
The i-th of the next q lines contains two integers x_i and y_i (1 ≤ x_i, y_i ≤ |s|, x_i ≠ y_i) — the two numbers given to the Jarvis for the i-th question.
Output
For each question output the number of arrangements possible modulo 10^9+7.
Examples
Input
abba
2
1 4
1 2
Output
2
0
Input
AAaa
2
1 2
1 3
Output
2
0
Input
abcd
1
1 3
Output
8
Note
Consider the first example. For the first question, the possible arrangements are "aabb" and "bbaa", and for the second question, index 1 contains 'a' and index 2 contains 'b' and there is no valid arrangement in which all 'a' and 'b' are in the same half.
Submitted Solution:
```
s=input()
n=len(s)
m=1000000007
fac=[1]
f=1
i=1
while i<=n+1:
f=(f*i)%m
fac.append(f)
i=i+1
ctr=[0]*125
i=0
while i<n:
ctr[ord(s[i])]=ctr[ord(s[i])]+1
i=i+1
dupFac=1
chars=[]
c=ord('a')
while c<=ord('z'):
dupFac=(dupFac*fac[ctr[c]])%m
chars.append(c)
c=c+1
c=ord('A')
while c<=ord('Z'):
dupFac=(dupFac*fac[ctr[c]])%m
chars.append(c)
c=c+1
dict={}
i=0
while i<len(chars):
c=chars[i]
j=0
while j<len(chars):
c2=chars[j]
villians = ctr[c]
if c!=c2:
villians = villians + ctr[c2]
if villians>int(n/2):
dict[(c,c2)]=0
dict[(c2,c)]=0
else:
left = int(n/2)-villians
ans = (2* (fac[int(n/2)] * fac[n-villians])%m )%m
ans = (ans * pow(fac[left], m-2, m) )%m
ans = (ans * pow(dupFac, m-2, m) )%m
dict[(c,c2)]=ans
if(c!=c2):
dict[(c2,c)]=ans
j=j+1
i=i+1
q=int(input())
i=0
while i<q:
z=input().split(' ')
x=int(z[0])
y=int(z[1])
print(dict[(ord(s[x-1]),ord(s[y-1]))])
i=i+1
```
|
instruction
| 0
| 851
| 2
| 1,702
|
No
|
output
| 1
| 851
| 2
| 1,703
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a colony of villains with several holes aligned in a row, where each hole contains exactly one villain.
Each colony arrangement can be expressed as a string of even length, where the i-th character of the string represents the type of villain in the i-th hole.
Iron Man can destroy a colony only if the colony arrangement is such that all villains of a certain type either live in the first half of the colony or in the second half of the colony.
His assistant Jarvis has a special power. It can swap villains of any two holes, i.e. swap any two characters in the string; he can do this operation any number of times.
Now Iron Man asks Jarvis q questions. In each question, he gives Jarvis two numbers x and y. Jarvis has to tell Iron Man the number of distinct colony arrangements he can create from the original one using his powers such that all villains having the same type as those originally living in x-th hole or y-th hole live in the same half and the Iron Man can destroy that colony arrangement.
Two colony arrangements are considered to be different if there exists a hole such that different types of villains are present in that hole in the arrangements.
Input
The first line contains a string s (2 ≤ |s| ≤ 10^{5}), representing the initial colony arrangement. String s can have both lowercase and uppercase English letters and its length is even.
The second line contains a single integer q (1 ≤ q ≤ 10^{5}) — the number of questions.
The i-th of the next q lines contains two integers x_i and y_i (1 ≤ x_i, y_i ≤ |s|, x_i ≠ y_i) — the two numbers given to the Jarvis for the i-th question.
Output
For each question output the number of arrangements possible modulo 10^9+7.
Examples
Input
abba
2
1 4
1 2
Output
2
0
Input
AAaa
2
1 2
1 3
Output
2
0
Input
abcd
1
1 3
Output
8
Note
Consider the first example. For the first question, the possible arrangements are "aabb" and "bbaa", and for the second question, index 1 contains 'a' and index 2 contains 'b' and there is no valid arrangement in which all 'a' and 'b' are in the same half.
Submitted Solution:
```
def get_pos(c):
if ord(c) <= ord('Z'):
return ord(c) - ord('A') + 26
return ord(c) - ord('a')
def add(a, b, MOD):
a = a + b
if a > MOD:
a -= MOD
return a
def sub(a, b, MOD):
a = a - b
if a < 0:
a += MOD
return a
data = input()
MOD = int(1e9 + 7)
cnt = [0 for i in range(52)]
for i in data:
cnt[get_pos(i)] += 1
factorical = [1]
for i in range(int(1e5 + 5)):
factorical.append(factorical[i] * (i + 1) % MOD)
inv = []
for i in factorical:
inv.append(pow(i, MOD - 2, MOD))
for i in range(len(inv)-1):
inv[i] = inv[i+1] * (i+1) % MOD
W = factorical[len(data) // 2] * factorical[len(data) // 2] % MOD
for i in cnt:
W = W * inv[i] % MOD
dp = [0 for i in range(len(data) + 10)]
dp[0] = 1
for i in range(len(cnt)):
if cnt[i] == 0:
continue
for j in range(len(dp) - 1, cnt[i] - 1, -1):
dp[j] = add(dp[j], dp[j - cnt[i]], MOD)
ans = [[0 for i in range(52)] for j in range(52)]
for i in range(len(cnt)):
ans[i][i] = dp[len(data) // 2] // 2
tmp_dp = dp[:]
for i in range(len(cnt)):
if cnt[i] == 0:
continue
for j in range(cnt[i], len(dp)):
tmp_dp[j] = sub(tmp_dp[j], tmp_dp[j - cnt[i]], MOD)
for j in range(i + 1, len(cnt)):
if cnt[j] == 0:
continue
for k in range(cnt[j], len(dp)):
tmp_dp[k] = sub(tmp_dp[k], tmp_dp[k - cnt[j]], MOD)
ans[i][j] = tmp_dp[len(data) // 2]
ans[j][i] = ans[i][j]
for k in range(len(dp) - 1, cnt[j] - 1, -1):
tmp_dp[k] = add(tmp_dp[k], tmp_dp[k - cnt[j]], MOD)
for j in range(len(dp) - 1, cnt[i] - 1, -1):
tmp_dp[j] = add(tmp_dp[j], tmp_dp[j - cnt[i]], MOD)
q = int(input())
for i in range(q):
[x, y] = list(map(int, input().split()))
x = get_pos(data[x - 1])
y = get_pos(data[y - 1])
out = ans[x][y] * W % MOD
out = out * 2 % MOD
print(out)
"""
ZbntHFIFBuavtylcuptFMJoBSlYGUnadhTPNHmnUqExWUSBEEBuuGxQiVLrrODmOSadswOPagtdQNadHoQofapdRigvOtLrmQVDXelInAaSBeRvFACbn
614
18 67
30 67
27 51
112 96
32 49
64 25
863016418
263652872
893809972
106197354
538185155
944461956
538185155
"""
```
|
instruction
| 0
| 852
| 2
| 1,704
|
No
|
output
| 1
| 852
| 2
| 1,705
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Once upon a time in the Kingdom of Far Far Away lived Sir Lancelot, the chief Royal General. He was very proud of his men and he liked to invite the King to come and watch drill exercises which demonstrated the fighting techniques and tactics of the squad he was in charge of. But time went by and one day Sir Lancelot had a major argument with the Fairy Godmother (there were rumors that the argument occurred after the general spoke badly of the Godmother's flying techniques. That seemed to hurt the Fairy Godmother very deeply).
As the result of the argument, the Godmother put a rather strange curse upon the general. It sounded all complicated and quite harmless: "If the squared distance between some two soldiers equals to 5, then those soldiers will conflict with each other!"
The drill exercises are held on a rectangular n × m field, split into nm square 1 × 1 segments for each soldier. Thus, the square of the distance between the soldiers that stand on squares (x1, y1) and (x2, y2) equals exactly (x1 - x2)2 + (y1 - y2)2. Now not all nm squad soldiers can participate in the drill exercises as it was before the Fairy Godmother's curse. Unless, of course, the general wants the soldiers to fight with each other or even worse... For example, if he puts a soldier in the square (2, 2), then he cannot put soldiers in the squares (1, 4), (3, 4), (4, 1) and (4, 3) — each of them will conflict with the soldier in the square (2, 2).
Your task is to help the general. You are given the size of the drill exercise field. You are asked to calculate the maximum number of soldiers that can be simultaneously positioned on this field, so that no two soldiers fall under the Fairy Godmother's curse.
Input
The single line contains space-separated integers n and m (1 ≤ n, m ≤ 1000) that represent the size of the drill exercise field.
Output
Print the desired maximum number of warriors.
Examples
Input
2 4
Output
4
Input
3 4
Output
6
Note
In the first sample test Sir Lancelot can place his 4 soldiers on the 2 × 4 court as follows (the soldiers' locations are marked with gray circles on the scheme):
<image>
In the second sample test he can place 6 soldiers on the 3 × 4 site in the following manner:
<image>
|
instruction
| 0
| 1,051
| 2
| 2,102
|
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
def voevoda(n, m):
if n == 1:
return m
if n == 2:
return (m - m % 4) + 2 * min(m % 4, 2)
return (n * m + 1) // 2
N, M = sorted([int(i) for i in input().split()])
print(voevoda(N, M))
```
|
output
| 1
| 1,051
| 2
| 2,103
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Once upon a time in the Kingdom of Far Far Away lived Sir Lancelot, the chief Royal General. He was very proud of his men and he liked to invite the King to come and watch drill exercises which demonstrated the fighting techniques and tactics of the squad he was in charge of. But time went by and one day Sir Lancelot had a major argument with the Fairy Godmother (there were rumors that the argument occurred after the general spoke badly of the Godmother's flying techniques. That seemed to hurt the Fairy Godmother very deeply).
As the result of the argument, the Godmother put a rather strange curse upon the general. It sounded all complicated and quite harmless: "If the squared distance between some two soldiers equals to 5, then those soldiers will conflict with each other!"
The drill exercises are held on a rectangular n × m field, split into nm square 1 × 1 segments for each soldier. Thus, the square of the distance between the soldiers that stand on squares (x1, y1) and (x2, y2) equals exactly (x1 - x2)2 + (y1 - y2)2. Now not all nm squad soldiers can participate in the drill exercises as it was before the Fairy Godmother's curse. Unless, of course, the general wants the soldiers to fight with each other or even worse... For example, if he puts a soldier in the square (2, 2), then he cannot put soldiers in the squares (1, 4), (3, 4), (4, 1) and (4, 3) — each of them will conflict with the soldier in the square (2, 2).
Your task is to help the general. You are given the size of the drill exercise field. You are asked to calculate the maximum number of soldiers that can be simultaneously positioned on this field, so that no two soldiers fall under the Fairy Godmother's curse.
Input
The single line contains space-separated integers n and m (1 ≤ n, m ≤ 1000) that represent the size of the drill exercise field.
Output
Print the desired maximum number of warriors.
Examples
Input
2 4
Output
4
Input
3 4
Output
6
Note
In the first sample test Sir Lancelot can place his 4 soldiers on the 2 × 4 court as follows (the soldiers' locations are marked with gray circles on the scheme):
<image>
In the second sample test he can place 6 soldiers on the 3 × 4 site in the following manner:
<image>
|
instruction
| 0
| 1,052
| 2
| 2,104
|
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
n,m=map(int,input().split())
if n>m:n,m=m,n
if n==1:print(m)
elif n==2:print((m//4)*4+min((m%4)*2,4))
else:print((n*m)-(n*m)//2)
```
|
output
| 1
| 1,052
| 2
| 2,105
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Once upon a time in the Kingdom of Far Far Away lived Sir Lancelot, the chief Royal General. He was very proud of his men and he liked to invite the King to come and watch drill exercises which demonstrated the fighting techniques and tactics of the squad he was in charge of. But time went by and one day Sir Lancelot had a major argument with the Fairy Godmother (there were rumors that the argument occurred after the general spoke badly of the Godmother's flying techniques. That seemed to hurt the Fairy Godmother very deeply).
As the result of the argument, the Godmother put a rather strange curse upon the general. It sounded all complicated and quite harmless: "If the squared distance between some two soldiers equals to 5, then those soldiers will conflict with each other!"
The drill exercises are held on a rectangular n × m field, split into nm square 1 × 1 segments for each soldier. Thus, the square of the distance between the soldiers that stand on squares (x1, y1) and (x2, y2) equals exactly (x1 - x2)2 + (y1 - y2)2. Now not all nm squad soldiers can participate in the drill exercises as it was before the Fairy Godmother's curse. Unless, of course, the general wants the soldiers to fight with each other or even worse... For example, if he puts a soldier in the square (2, 2), then he cannot put soldiers in the squares (1, 4), (3, 4), (4, 1) and (4, 3) — each of them will conflict with the soldier in the square (2, 2).
Your task is to help the general. You are given the size of the drill exercise field. You are asked to calculate the maximum number of soldiers that can be simultaneously positioned on this field, so that no two soldiers fall under the Fairy Godmother's curse.
Input
The single line contains space-separated integers n and m (1 ≤ n, m ≤ 1000) that represent the size of the drill exercise field.
Output
Print the desired maximum number of warriors.
Examples
Input
2 4
Output
4
Input
3 4
Output
6
Note
In the first sample test Sir Lancelot can place his 4 soldiers on the 2 × 4 court as follows (the soldiers' locations are marked with gray circles on the scheme):
<image>
In the second sample test he can place 6 soldiers on the 3 × 4 site in the following manner:
<image>
|
instruction
| 0
| 1,053
| 2
| 2,106
|
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
def li():
return list(map(int, input().split(" ")))
n, m = li()
if n < m:
t =n
n = m
m = t
if m == 1:
print(n)
elif m == 2:
print(2*(2*(n//4) + min(n%4, 2)))
else:
print((n*m) - (n*m)//2)
```
|
output
| 1
| 1,053
| 2
| 2,107
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Once upon a time in the Kingdom of Far Far Away lived Sir Lancelot, the chief Royal General. He was very proud of his men and he liked to invite the King to come and watch drill exercises which demonstrated the fighting techniques and tactics of the squad he was in charge of. But time went by and one day Sir Lancelot had a major argument with the Fairy Godmother (there were rumors that the argument occurred after the general spoke badly of the Godmother's flying techniques. That seemed to hurt the Fairy Godmother very deeply).
As the result of the argument, the Godmother put a rather strange curse upon the general. It sounded all complicated and quite harmless: "If the squared distance between some two soldiers equals to 5, then those soldiers will conflict with each other!"
The drill exercises are held on a rectangular n × m field, split into nm square 1 × 1 segments for each soldier. Thus, the square of the distance between the soldiers that stand on squares (x1, y1) and (x2, y2) equals exactly (x1 - x2)2 + (y1 - y2)2. Now not all nm squad soldiers can participate in the drill exercises as it was before the Fairy Godmother's curse. Unless, of course, the general wants the soldiers to fight with each other or even worse... For example, if he puts a soldier in the square (2, 2), then he cannot put soldiers in the squares (1, 4), (3, 4), (4, 1) and (4, 3) — each of them will conflict with the soldier in the square (2, 2).
Your task is to help the general. You are given the size of the drill exercise field. You are asked to calculate the maximum number of soldiers that can be simultaneously positioned on this field, so that no two soldiers fall under the Fairy Godmother's curse.
Input
The single line contains space-separated integers n and m (1 ≤ n, m ≤ 1000) that represent the size of the drill exercise field.
Output
Print the desired maximum number of warriors.
Examples
Input
2 4
Output
4
Input
3 4
Output
6
Note
In the first sample test Sir Lancelot can place his 4 soldiers on the 2 × 4 court as follows (the soldiers' locations are marked with gray circles on the scheme):
<image>
In the second sample test he can place 6 soldiers on the 3 × 4 site in the following manner:
<image>
|
instruction
| 0
| 1,054
| 2
| 2,108
|
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
s=input().split()
n=int(s[0])
m=int(s[1])
if (n>m):
a=n
n=m
m=a
if (n==1):
print(m)
elif (n==2):
if (m%4<=2):
print(m+m%4)
else:
print(m+1)
else:
print((n*m+1)//2)
```
|
output
| 1
| 1,054
| 2
| 2,109
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Once upon a time in the Kingdom of Far Far Away lived Sir Lancelot, the chief Royal General. He was very proud of his men and he liked to invite the King to come and watch drill exercises which demonstrated the fighting techniques and tactics of the squad he was in charge of. But time went by and one day Sir Lancelot had a major argument with the Fairy Godmother (there were rumors that the argument occurred after the general spoke badly of the Godmother's flying techniques. That seemed to hurt the Fairy Godmother very deeply).
As the result of the argument, the Godmother put a rather strange curse upon the general. It sounded all complicated and quite harmless: "If the squared distance between some two soldiers equals to 5, then those soldiers will conflict with each other!"
The drill exercises are held on a rectangular n × m field, split into nm square 1 × 1 segments for each soldier. Thus, the square of the distance between the soldiers that stand on squares (x1, y1) and (x2, y2) equals exactly (x1 - x2)2 + (y1 - y2)2. Now not all nm squad soldiers can participate in the drill exercises as it was before the Fairy Godmother's curse. Unless, of course, the general wants the soldiers to fight with each other or even worse... For example, if he puts a soldier in the square (2, 2), then he cannot put soldiers in the squares (1, 4), (3, 4), (4, 1) and (4, 3) — each of them will conflict with the soldier in the square (2, 2).
Your task is to help the general. You are given the size of the drill exercise field. You are asked to calculate the maximum number of soldiers that can be simultaneously positioned on this field, so that no two soldiers fall under the Fairy Godmother's curse.
Input
The single line contains space-separated integers n and m (1 ≤ n, m ≤ 1000) that represent the size of the drill exercise field.
Output
Print the desired maximum number of warriors.
Examples
Input
2 4
Output
4
Input
3 4
Output
6
Note
In the first sample test Sir Lancelot can place his 4 soldiers on the 2 × 4 court as follows (the soldiers' locations are marked with gray circles on the scheme):
<image>
In the second sample test he can place 6 soldiers on the 3 × 4 site in the following manner:
<image>
|
instruction
| 0
| 1,055
| 2
| 2,110
|
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
n, m = map(int, input().split())
if n > m:
n, m = m, n
if n > 2 and m > 2:
print(((n * m) + 1) // 2)
elif n == 1:
print(m)
else:
print(2 * (((m // 4) * 2) + min(m % 4, 2)))
# Made By Mostafa_Khaled
```
|
output
| 1
| 1,055
| 2
| 2,111
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Once upon a time in the Kingdom of Far Far Away lived Sir Lancelot, the chief Royal General. He was very proud of his men and he liked to invite the King to come and watch drill exercises which demonstrated the fighting techniques and tactics of the squad he was in charge of. But time went by and one day Sir Lancelot had a major argument with the Fairy Godmother (there were rumors that the argument occurred after the general spoke badly of the Godmother's flying techniques. That seemed to hurt the Fairy Godmother very deeply).
As the result of the argument, the Godmother put a rather strange curse upon the general. It sounded all complicated and quite harmless: "If the squared distance between some two soldiers equals to 5, then those soldiers will conflict with each other!"
The drill exercises are held on a rectangular n × m field, split into nm square 1 × 1 segments for each soldier. Thus, the square of the distance between the soldiers that stand on squares (x1, y1) and (x2, y2) equals exactly (x1 - x2)2 + (y1 - y2)2. Now not all nm squad soldiers can participate in the drill exercises as it was before the Fairy Godmother's curse. Unless, of course, the general wants the soldiers to fight with each other or even worse... For example, if he puts a soldier in the square (2, 2), then he cannot put soldiers in the squares (1, 4), (3, 4), (4, 1) and (4, 3) — each of them will conflict with the soldier in the square (2, 2).
Your task is to help the general. You are given the size of the drill exercise field. You are asked to calculate the maximum number of soldiers that can be simultaneously positioned on this field, so that no two soldiers fall under the Fairy Godmother's curse.
Input
The single line contains space-separated integers n and m (1 ≤ n, m ≤ 1000) that represent the size of the drill exercise field.
Output
Print the desired maximum number of warriors.
Examples
Input
2 4
Output
4
Input
3 4
Output
6
Note
In the first sample test Sir Lancelot can place his 4 soldiers on the 2 × 4 court as follows (the soldiers' locations are marked with gray circles on the scheme):
<image>
In the second sample test he can place 6 soldiers on the 3 × 4 site in the following manner:
<image>
|
instruction
| 0
| 1,056
| 2
| 2,112
|
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
n,m=sorted(list(map(int,input().split())))
if n==1:
print(m)
elif n==2:
print(4*((n*m)//8)+min((n*m)%8,4))
else:
print(n*m//2+n*m%2)
```
|
output
| 1
| 1,056
| 2
| 2,113
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Once upon a time in the Kingdom of Far Far Away lived Sir Lancelot, the chief Royal General. He was very proud of his men and he liked to invite the King to come and watch drill exercises which demonstrated the fighting techniques and tactics of the squad he was in charge of. But time went by and one day Sir Lancelot had a major argument with the Fairy Godmother (there were rumors that the argument occurred after the general spoke badly of the Godmother's flying techniques. That seemed to hurt the Fairy Godmother very deeply).
As the result of the argument, the Godmother put a rather strange curse upon the general. It sounded all complicated and quite harmless: "If the squared distance between some two soldiers equals to 5, then those soldiers will conflict with each other!"
The drill exercises are held on a rectangular n × m field, split into nm square 1 × 1 segments for each soldier. Thus, the square of the distance between the soldiers that stand on squares (x1, y1) and (x2, y2) equals exactly (x1 - x2)2 + (y1 - y2)2. Now not all nm squad soldiers can participate in the drill exercises as it was before the Fairy Godmother's curse. Unless, of course, the general wants the soldiers to fight with each other or even worse... For example, if he puts a soldier in the square (2, 2), then he cannot put soldiers in the squares (1, 4), (3, 4), (4, 1) and (4, 3) — each of them will conflict with the soldier in the square (2, 2).
Your task is to help the general. You are given the size of the drill exercise field. You are asked to calculate the maximum number of soldiers that can be simultaneously positioned on this field, so that no two soldiers fall under the Fairy Godmother's curse.
Input
The single line contains space-separated integers n and m (1 ≤ n, m ≤ 1000) that represent the size of the drill exercise field.
Output
Print the desired maximum number of warriors.
Examples
Input
2 4
Output
4
Input
3 4
Output
6
Note
In the first sample test Sir Lancelot can place his 4 soldiers on the 2 × 4 court as follows (the soldiers' locations are marked with gray circles on the scheme):
<image>
In the second sample test he can place 6 soldiers on the 3 × 4 site in the following manner:
<image>
|
instruction
| 0
| 1,057
| 2
| 2,114
|
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
n, m = sorted(map(int, input().split()))
k = 4 * (m >> 2)
print(m if n == 1 else k + 2 * min(2, m - k) if n == 2 else (m * n + 1 >> 1))
```
|
output
| 1
| 1,057
| 2
| 2,115
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Once upon a time in the Kingdom of Far Far Away lived Sir Lancelot, the chief Royal General. He was very proud of his men and he liked to invite the King to come and watch drill exercises which demonstrated the fighting techniques and tactics of the squad he was in charge of. But time went by and one day Sir Lancelot had a major argument with the Fairy Godmother (there were rumors that the argument occurred after the general spoke badly of the Godmother's flying techniques. That seemed to hurt the Fairy Godmother very deeply).
As the result of the argument, the Godmother put a rather strange curse upon the general. It sounded all complicated and quite harmless: "If the squared distance between some two soldiers equals to 5, then those soldiers will conflict with each other!"
The drill exercises are held on a rectangular n × m field, split into nm square 1 × 1 segments for each soldier. Thus, the square of the distance between the soldiers that stand on squares (x1, y1) and (x2, y2) equals exactly (x1 - x2)2 + (y1 - y2)2. Now not all nm squad soldiers can participate in the drill exercises as it was before the Fairy Godmother's curse. Unless, of course, the general wants the soldiers to fight with each other or even worse... For example, if he puts a soldier in the square (2, 2), then he cannot put soldiers in the squares (1, 4), (3, 4), (4, 1) and (4, 3) — each of them will conflict with the soldier in the square (2, 2).
Your task is to help the general. You are given the size of the drill exercise field. You are asked to calculate the maximum number of soldiers that can be simultaneously positioned on this field, so that no two soldiers fall under the Fairy Godmother's curse.
Input
The single line contains space-separated integers n and m (1 ≤ n, m ≤ 1000) that represent the size of the drill exercise field.
Output
Print the desired maximum number of warriors.
Examples
Input
2 4
Output
4
Input
3 4
Output
6
Note
In the first sample test Sir Lancelot can place his 4 soldiers on the 2 × 4 court as follows (the soldiers' locations are marked with gray circles on the scheme):
<image>
In the second sample test he can place 6 soldiers on the 3 × 4 site in the following manner:
<image>
|
instruction
| 0
| 1,058
| 2
| 2,116
|
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
n, m = map(int, input().split())
if n > m:
n, m = m, n
if n > 2 and m > 2:
print(((n * m) + 1) // 2)
elif n == 1:
print(m)
else:
print(2 * (((m // 4) * 2) + min(m % 4, 2)))
```
|
output
| 1
| 1,058
| 2
| 2,117
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once upon a time in the Kingdom of Far Far Away lived Sir Lancelot, the chief Royal General. He was very proud of his men and he liked to invite the King to come and watch drill exercises which demonstrated the fighting techniques and tactics of the squad he was in charge of. But time went by and one day Sir Lancelot had a major argument with the Fairy Godmother (there were rumors that the argument occurred after the general spoke badly of the Godmother's flying techniques. That seemed to hurt the Fairy Godmother very deeply).
As the result of the argument, the Godmother put a rather strange curse upon the general. It sounded all complicated and quite harmless: "If the squared distance between some two soldiers equals to 5, then those soldiers will conflict with each other!"
The drill exercises are held on a rectangular n × m field, split into nm square 1 × 1 segments for each soldier. Thus, the square of the distance between the soldiers that stand on squares (x1, y1) and (x2, y2) equals exactly (x1 - x2)2 + (y1 - y2)2. Now not all nm squad soldiers can participate in the drill exercises as it was before the Fairy Godmother's curse. Unless, of course, the general wants the soldiers to fight with each other or even worse... For example, if he puts a soldier in the square (2, 2), then he cannot put soldiers in the squares (1, 4), (3, 4), (4, 1) and (4, 3) — each of them will conflict with the soldier in the square (2, 2).
Your task is to help the general. You are given the size of the drill exercise field. You are asked to calculate the maximum number of soldiers that can be simultaneously positioned on this field, so that no two soldiers fall under the Fairy Godmother's curse.
Input
The single line contains space-separated integers n and m (1 ≤ n, m ≤ 1000) that represent the size of the drill exercise field.
Output
Print the desired maximum number of warriors.
Examples
Input
2 4
Output
4
Input
3 4
Output
6
Note
In the first sample test Sir Lancelot can place his 4 soldiers on the 2 × 4 court as follows (the soldiers' locations are marked with gray circles on the scheme):
<image>
In the second sample test he can place 6 soldiers on the 3 × 4 site in the following manner:
<image>
Submitted Solution:
```
ab=input().split(' ')
a=int(ab[0])
b=int(ab[1])
c=a*b
print(c//2)
```
|
instruction
| 0
| 1,059
| 2
| 2,118
|
No
|
output
| 1
| 1,059
| 2
| 2,119
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once upon a time in the Kingdom of Far Far Away lived Sir Lancelot, the chief Royal General. He was very proud of his men and he liked to invite the King to come and watch drill exercises which demonstrated the fighting techniques and tactics of the squad he was in charge of. But time went by and one day Sir Lancelot had a major argument with the Fairy Godmother (there were rumors that the argument occurred after the general spoke badly of the Godmother's flying techniques. That seemed to hurt the Fairy Godmother very deeply).
As the result of the argument, the Godmother put a rather strange curse upon the general. It sounded all complicated and quite harmless: "If the squared distance between some two soldiers equals to 5, then those soldiers will conflict with each other!"
The drill exercises are held on a rectangular n × m field, split into nm square 1 × 1 segments for each soldier. Thus, the square of the distance between the soldiers that stand on squares (x1, y1) and (x2, y2) equals exactly (x1 - x2)2 + (y1 - y2)2. Now not all nm squad soldiers can participate in the drill exercises as it was before the Fairy Godmother's curse. Unless, of course, the general wants the soldiers to fight with each other or even worse... For example, if he puts a soldier in the square (2, 2), then he cannot put soldiers in the squares (1, 4), (3, 4), (4, 1) and (4, 3) — each of them will conflict with the soldier in the square (2, 2).
Your task is to help the general. You are given the size of the drill exercise field. You are asked to calculate the maximum number of soldiers that can be simultaneously positioned on this field, so that no two soldiers fall under the Fairy Godmother's curse.
Input
The single line contains space-separated integers n and m (1 ≤ n, m ≤ 1000) that represent the size of the drill exercise field.
Output
Print the desired maximum number of warriors.
Examples
Input
2 4
Output
4
Input
3 4
Output
6
Note
In the first sample test Sir Lancelot can place his 4 soldiers on the 2 × 4 court as follows (the soldiers' locations are marked with gray circles on the scheme):
<image>
In the second sample test he can place 6 soldiers on the 3 × 4 site in the following manner:
<image>
Submitted Solution:
```
n,m=map(int,input().split())
if n%3==0:
c=n/3
else:
c=n//3+1
if m%3==0:
p=m/3
else:p=m//3+1
print(max(c*m,p*n))
```
|
instruction
| 0
| 1,060
| 2
| 2,120
|
No
|
output
| 1
| 1,060
| 2
| 2,121
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once upon a time in the Kingdom of Far Far Away lived Sir Lancelot, the chief Royal General. He was very proud of his men and he liked to invite the King to come and watch drill exercises which demonstrated the fighting techniques and tactics of the squad he was in charge of. But time went by and one day Sir Lancelot had a major argument with the Fairy Godmother (there were rumors that the argument occurred after the general spoke badly of the Godmother's flying techniques. That seemed to hurt the Fairy Godmother very deeply).
As the result of the argument, the Godmother put a rather strange curse upon the general. It sounded all complicated and quite harmless: "If the squared distance between some two soldiers equals to 5, then those soldiers will conflict with each other!"
The drill exercises are held on a rectangular n × m field, split into nm square 1 × 1 segments for each soldier. Thus, the square of the distance between the soldiers that stand on squares (x1, y1) and (x2, y2) equals exactly (x1 - x2)2 + (y1 - y2)2. Now not all nm squad soldiers can participate in the drill exercises as it was before the Fairy Godmother's curse. Unless, of course, the general wants the soldiers to fight with each other or even worse... For example, if he puts a soldier in the square (2, 2), then he cannot put soldiers in the squares (1, 4), (3, 4), (4, 1) and (4, 3) — each of them will conflict with the soldier in the square (2, 2).
Your task is to help the general. You are given the size of the drill exercise field. You are asked to calculate the maximum number of soldiers that can be simultaneously positioned on this field, so that no two soldiers fall under the Fairy Godmother's curse.
Input
The single line contains space-separated integers n and m (1 ≤ n, m ≤ 1000) that represent the size of the drill exercise field.
Output
Print the desired maximum number of warriors.
Examples
Input
2 4
Output
4
Input
3 4
Output
6
Note
In the first sample test Sir Lancelot can place his 4 soldiers on the 2 × 4 court as follows (the soldiers' locations are marked with gray circles on the scheme):
<image>
In the second sample test he can place 6 soldiers on the 3 × 4 site in the following manner:
<image>
Submitted Solution:
```
ab=input().split(' ')
a=int(ab[0])
b=int(ab[1])
c=a*b
if c>1: print(c//2)
elif c==1: print(1)
```
|
instruction
| 0
| 1,061
| 2
| 2,122
|
No
|
output
| 1
| 1,061
| 2
| 2,123
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once upon a time in the Kingdom of Far Far Away lived Sir Lancelot, the chief Royal General. He was very proud of his men and he liked to invite the King to come and watch drill exercises which demonstrated the fighting techniques and tactics of the squad he was in charge of. But time went by and one day Sir Lancelot had a major argument with the Fairy Godmother (there were rumors that the argument occurred after the general spoke badly of the Godmother's flying techniques. That seemed to hurt the Fairy Godmother very deeply).
As the result of the argument, the Godmother put a rather strange curse upon the general. It sounded all complicated and quite harmless: "If the squared distance between some two soldiers equals to 5, then those soldiers will conflict with each other!"
The drill exercises are held on a rectangular n × m field, split into nm square 1 × 1 segments for each soldier. Thus, the square of the distance between the soldiers that stand on squares (x1, y1) and (x2, y2) equals exactly (x1 - x2)2 + (y1 - y2)2. Now not all nm squad soldiers can participate in the drill exercises as it was before the Fairy Godmother's curse. Unless, of course, the general wants the soldiers to fight with each other or even worse... For example, if he puts a soldier in the square (2, 2), then he cannot put soldiers in the squares (1, 4), (3, 4), (4, 1) and (4, 3) — each of them will conflict with the soldier in the square (2, 2).
Your task is to help the general. You are given the size of the drill exercise field. You are asked to calculate the maximum number of soldiers that can be simultaneously positioned on this field, so that no two soldiers fall under the Fairy Godmother's curse.
Input
The single line contains space-separated integers n and m (1 ≤ n, m ≤ 1000) that represent the size of the drill exercise field.
Output
Print the desired maximum number of warriors.
Examples
Input
2 4
Output
4
Input
3 4
Output
6
Note
In the first sample test Sir Lancelot can place his 4 soldiers on the 2 × 4 court as follows (the soldiers' locations are marked with gray circles on the scheme):
<image>
In the second sample test he can place 6 soldiers on the 3 × 4 site in the following manner:
<image>
Submitted Solution:
```
ab=input().split(' ')
a=int(ab[0])
b=int(ab[1])
c=a*b
if c&2!=0:
if c>1: print(c//2+1)
elif c==1: print(1)
else:
if c>1: print(c//2)
elif c==1: print(1)
```
|
instruction
| 0
| 1,062
| 2
| 2,124
|
No
|
output
| 1
| 1,062
| 2
| 2,125
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Priests of the Quetzalcoatl cult want to build a tower to represent a power of their god. Tower is usually made of power-charged rocks. It is built with the help of rare magic by levitating the current top of tower and adding rocks at its bottom. If top, which is built from k - 1 rocks, possesses power p and we want to add the rock charged with power wk then value of power of a new tower will be {wk}p.
Rocks are added from the last to the first. That is for sequence w1, ..., wm value of power will be
<image>
After tower is built, its power may be extremely large. But still priests want to get some information about it, namely they want to know a number called cumulative power which is the true value of power taken modulo m. Priests have n rocks numbered from 1 to n. They ask you to calculate which value of cumulative power will the tower possess if they will build it from rocks numbered l, l + 1, ..., r.
Input
First line of input contains two integers n (1 ≤ n ≤ 105) and m (1 ≤ m ≤ 109).
Second line of input contains n integers wk (1 ≤ wk ≤ 109) which is the power of rocks that priests have.
Third line of input contains single integer q (1 ≤ q ≤ 105) which is amount of queries from priests to you.
kth of next q lines contains two integers lk and rk (1 ≤ lk ≤ rk ≤ n).
Output
Output q integers. k-th of them must be the amount of cumulative power the tower will have if is built from rocks lk, lk + 1, ..., rk.
Example
Input
6 1000000000
1 2 2 3 3 3
8
1 1
1 6
2 2
2 3
2 4
4 4
4 5
4 6
Output
1
1
2
4
256
3
27
597484987
Note
327 = 7625597484987
Submitted Solution:
```
def build():
num = m
for i in range(n):
mods.append(num)
num = phi(num)
def phi(number):
number = int(number)
res = number
if number % 2 == 0:
while number % 2 == 0:
number //= 2
res -= res // 2
for i in range(3, number + 1):
if number % i == 0:
while number % i == 0:
number //= i
res -= res // i
return res
def chained_pow(w, level):
if len(w) == 1:
return int(w[0] % mods[level])
else:
return int(pow(w[0], chained_pow(w[1:], level+1), mods[level]))
mods = []
_ = [int(x) for x in input().split()]
n = _[0]
m = _[1]
a = [int(x) for x in input().split()]
build()
q = int(input())
for __ in range(q):
_q = [int(x) for x in input().split()]
left = _q[0]
right = _q[1]
print(chained_pow(a[left-1:right], 0))
```
|
instruction
| 0
| 1,408
| 2
| 2,816
|
No
|
output
| 1
| 1,408
| 2
| 2,817
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Priests of the Quetzalcoatl cult want to build a tower to represent a power of their god. Tower is usually made of power-charged rocks. It is built with the help of rare magic by levitating the current top of tower and adding rocks at its bottom. If top, which is built from k - 1 rocks, possesses power p and we want to add the rock charged with power wk then value of power of a new tower will be {wk}p.
Rocks are added from the last to the first. That is for sequence w1, ..., wm value of power will be
<image>
After tower is built, its power may be extremely large. But still priests want to get some information about it, namely they want to know a number called cumulative power which is the true value of power taken modulo m. Priests have n rocks numbered from 1 to n. They ask you to calculate which value of cumulative power will the tower possess if they will build it from rocks numbered l, l + 1, ..., r.
Input
First line of input contains two integers n (1 ≤ n ≤ 105) and m (1 ≤ m ≤ 109).
Second line of input contains n integers wk (1 ≤ wk ≤ 109) which is the power of rocks that priests have.
Third line of input contains single integer q (1 ≤ q ≤ 105) which is amount of queries from priests to you.
kth of next q lines contains two integers lk and rk (1 ≤ lk ≤ rk ≤ n).
Output
Output q integers. k-th of them must be the amount of cumulative power the tower will have if is built from rocks lk, lk + 1, ..., rk.
Example
Input
6 1000000000
1 2 2 3 3 3
8
1 1
1 6
2 2
2 3
2 4
4 4
4 5
4 6
Output
1
1
2
4
256
3
27
597484987
Note
327 = 7625597484987
Submitted Solution:
```
MOD = 10**9 + 7
def pow( a, b, mod ):
ret = 1
while b > 0:
if b & 1:
ret = ( ret * a ) % mod
a = ( a * a ) % mod
b //= 2
return ( ret )
def phi( n ):
ans = n
i = 2
while i * i <= n:
if n % i == 0:
ans -= ans//i
while n % i == 0:
n //= i
i += 1
if n != 1:
ans -= ans // n
return ( ans )
x = MOD
P = [ x ]
while True:
x = phi(x)
P.append(x)
if x == 1:
break
n, m = list( map( int, input().split() ) )
w = list( map( int, input().split() ) )
q = int( input() )
def solve( left, right, who ):
if P[who] == 1:
return 1
if left == right:
return w[left] % P[who]
ret = pow( w[left], solve(left+1,right,who+1), P[who] )
return ( ret )
for i in range(q):
l, r = list( map( int, input().split() ) )
print( solve(l-1,r-1, 0) )
```
|
instruction
| 0
| 1,409
| 2
| 2,818
|
No
|
output
| 1
| 1,409
| 2
| 2,819
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Priests of the Quetzalcoatl cult want to build a tower to represent a power of their god. Tower is usually made of power-charged rocks. It is built with the help of rare magic by levitating the current top of tower and adding rocks at its bottom. If top, which is built from k - 1 rocks, possesses power p and we want to add the rock charged with power wk then value of power of a new tower will be {wk}p.
Rocks are added from the last to the first. That is for sequence w1, ..., wm value of power will be
<image>
After tower is built, its power may be extremely large. But still priests want to get some information about it, namely they want to know a number called cumulative power which is the true value of power taken modulo m. Priests have n rocks numbered from 1 to n. They ask you to calculate which value of cumulative power will the tower possess if they will build it from rocks numbered l, l + 1, ..., r.
Input
First line of input contains two integers n (1 ≤ n ≤ 105) and m (1 ≤ m ≤ 109).
Second line of input contains n integers wk (1 ≤ wk ≤ 109) which is the power of rocks that priests have.
Third line of input contains single integer q (1 ≤ q ≤ 105) which is amount of queries from priests to you.
kth of next q lines contains two integers lk and rk (1 ≤ lk ≤ rk ≤ n).
Output
Output q integers. k-th of them must be the amount of cumulative power the tower will have if is built from rocks lk, lk + 1, ..., rk.
Example
Input
6 1000000000
1 2 2 3 3 3
8
1 1
1 6
2 2
2 3
2 4
4 4
4 5
4 6
Output
1
1
2
4
256
3
27
597484987
Note
327 = 7625597484987
Submitted Solution:
```
def f(r,l):
s=l-r+1
while len(ar[l])<s:
ar[l].append(pow(w[l-len(ar[l])],ar[l][-1],m))
return(ar[l][s-1])
n,m=map(int,input().split())
w=list(map(int,input().split()))
q=int(input())
ar={}
for i in range(q):
r,l=map(int,input().split())
r,l=r-1,l-1
if l not in ar:
ar[l]=[w[l]]
print(f(r,l))
```
|
instruction
| 0
| 1,410
| 2
| 2,820
|
No
|
output
| 1
| 1,410
| 2
| 2,821
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Priests of the Quetzalcoatl cult want to build a tower to represent a power of their god. Tower is usually made of power-charged rocks. It is built with the help of rare magic by levitating the current top of tower and adding rocks at its bottom. If top, which is built from k - 1 rocks, possesses power p and we want to add the rock charged with power wk then value of power of a new tower will be {wk}p.
Rocks are added from the last to the first. That is for sequence w1, ..., wm value of power will be
<image>
After tower is built, its power may be extremely large. But still priests want to get some information about it, namely they want to know a number called cumulative power which is the true value of power taken modulo m. Priests have n rocks numbered from 1 to n. They ask you to calculate which value of cumulative power will the tower possess if they will build it from rocks numbered l, l + 1, ..., r.
Input
First line of input contains two integers n (1 ≤ n ≤ 105) and m (1 ≤ m ≤ 109).
Second line of input contains n integers wk (1 ≤ wk ≤ 109) which is the power of rocks that priests have.
Third line of input contains single integer q (1 ≤ q ≤ 105) which is amount of queries from priests to you.
kth of next q lines contains two integers lk and rk (1 ≤ lk ≤ rk ≤ n).
Output
Output q integers. k-th of them must be the amount of cumulative power the tower will have if is built from rocks lk, lk + 1, ..., rk.
Example
Input
6 1000000000
1 2 2 3 3 3
8
1 1
1 6
2 2
2 3
2 4
4 4
4 5
4 6
Output
1
1
2
4
256
3
27
597484987
Note
327 = 7625597484987
Submitted Solution:
```
class Tower:
def __init__(self, n, m):
self.n = n
self.m = m
self.w = []
self.q = 0
def add_w(self, w):
self.w.append(w)
def set_q(self, q):
self.q = q
def ask(self, left, right):
num = right - left + 1
result = 1
for n in range(num):
result = pow(self.w[right - n], result, self.m)
return result
line = input().split(" ")
tower = Tower(int(line[0]), int(line[1]))
line = input().split(" ")
for item in line:
tower.add_w(int(item))
q = int(input())
for i in range(q):
line = input().split(" ")
print(tower.ask(int(line[0]) - 1, int(line[1]) - 1))
```
|
instruction
| 0
| 1,411
| 2
| 2,822
|
No
|
output
| 1
| 1,411
| 2
| 2,823
|
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
| 1,922
| 2
| 3,844
|
Tags: dp
Correct Solution:
```
# n = 24
def get_subs(n):
count = 0
while n != '0':
digits = [int(i) for i in n]
max_digit = max(digits)
n = int(n) - max_digit
n = str(n)
count += 1
return count
if __name__ == '__main__':
n = input()
print(get_subs(n))
```
|
output
| 1
| 1,922
| 2
| 3,845
|
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
| 1,923
| 2
| 3,846
|
Tags: dp
Correct Solution:
```
t = int(input())
c = 0
while t!=0:
c+=1
t = t-int(max(str(t)))
print(c)
```
|
output
| 1
| 1,923
| 2
| 3,847
|
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
| 1,924
| 2
| 3,848
|
Tags: dp
Correct Solution:
```
n = int(input())
count = 0
while n:
maxi = 0
nn = n
while nn:
maxi = max(maxi, nn%10)
nn //= 10
count += 1
n -= maxi
print(count)
```
|
output
| 1
| 1,924
| 2
| 3,849
|
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
| 1,925
| 2
| 3,850
|
Tags: dp
Correct Solution:
```
import math
from math import gcd,floor,sqrt,log
def iin(): return int(input())
def sin(): return input().strip()
def listin(): return list(map(int,input().strip().split()))
def liststr(): return list(map(str,input().strip().split()))
def ceill(x): return int(x) if(x==int(x)) else int(x)+1
def ceilldiv(x,d): x//d if(x%d==0) else x//d+1
def LCM(a,b): return (a*b)//gcd(a,b)
n = iin()
cnt=0
while n>0:
n -= int(max(str(n)))
cnt+=1
print(cnt)
```
|
output
| 1
| 1,925
| 2
| 3,851
|
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
| 1,926
| 2
| 3,852
|
Tags: dp
Correct Solution:
```
import math
import sys
input = sys.stdin.readline
n = int(input())
opt = 0
while n != 0:
n -= int(max(list(str(n))))
opt += 1
print(opt)
```
|
output
| 1
| 1,926
| 2
| 3,853
|
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
| 1,927
| 2
| 3,854
|
Tags: dp
Correct Solution:
```
n = int(input())
f = n
s = 1
while n > 9:
n -= max(map(int, str(n)))
s += 1
if f == 0: print(0)
else: print(s)
```
|
output
| 1
| 1,927
| 2
| 3,855
|
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
| 1,928
| 2
| 3,856
|
Tags: dp
Correct Solution:
```
from sys import stdin,stdout
from math import gcd,sqrt,factorial,inf
from collections import deque,defaultdict
input=stdin.readline
R=lambda:map(int,input().split())
I=lambda:int(input())
S=lambda:input().rstrip('\n')
L=lambda:list(R())
P=lambda x:stdout.write(x)
lcm=lambda x,y:(x*y)//gcd(x,y)
hg=lambda x,y:((y+x-1)//x)*x
pw=lambda x:0 if x==1 else 1+pw(x//2)
chk=lambda x:chk(x//2) if not x%2 else True if x==1 else False
sm=lambda x:(x**2+x)//2
N=10**9+7
def max_int(n):
m=-inf
while n:
m=max(m,n%10)
n//=10
return m
n=I()
ans=0
while n:
ans+=1
n-=max_int(n)
print(ans)
```
|
output
| 1
| 1,928
| 2
| 3,857
|
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
| 1,929
| 2
| 3,858
|
Tags: dp
Correct Solution:
```
n = int(input())
k = 0
m = 0
while int(n) != 0:
m = int(max(str(n)))
n -= m
k += 1
print(k)
```
|
output
| 1
| 1,929
| 2
| 3,859
|
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:
```
n=int(input())
dp=[0]+[1e9+7]*(n)
for i in range(1,n+1):
tmp=i
while tmp:
dp[i]=min(dp[i],dp[i-tmp%10]+1)
tmp//=10
print(int(dp[n]))
```
|
instruction
| 0
| 1,930
| 2
| 3,860
|
Yes
|
output
| 1
| 1,930
| 2
| 3,861
|
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:
```
n, count = int(input()), 0
while n > 0:
nList = [int(i) for i in str(n)]
n -= max(nList)
count += 1
print(count)
```
|
instruction
| 0
| 1,931
| 2
| 3,862
|
Yes
|
output
| 1
| 1,931
| 2
| 3,863
|
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:
```
n = input()
cnt = 0
while int(n) > 0:
n = str(int(n) - int(max(n)))
cnt += 1
print(cnt)
```
|
instruction
| 0
| 1,932
| 2
| 3,864
|
Yes
|
output
| 1
| 1,932
| 2
| 3,865
|
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:
```
n = int(input())
steps = 0
while n:
n -= int(max(str(n)))
steps+=1
print(steps)
```
|
instruction
| 0
| 1,933
| 2
| 3,866
|
Yes
|
output
| 1
| 1,933
| 2
| 3,867
|
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:
```
from math import *
from copy import *
from string import * # alpha = ascii_lowercase
from random import *
from sys import stdin
from sys import maxsize
from operator import * # d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter # d = dict(Counter(l))
import math
def bin1(l,r,k,t,b,val,ans):
if(l>r):
return ans
else:
mid=(l+r)//2
v=k**mid
if(v==val):
return v
elif(v>val):
ans=mid
return bin1(mid+1,r,k,t,b,val,ans)
else:
return bin1(l,mid-1,k,t,b,val,ans)
def bin2(l,r,k,t,b,val,ans):
if(l>r):
return ans
else:
mid=(l+r)//2
v=t*(k**mid)+b*(mid)
if(v==val):
return v
elif(v>val):
ans=mid
return bin2(l,mid-1,k,t,b,val,ans)
else:
return bin2(mid+1,r,k,t,b,val,ans)
def SieveOfEratosthenes(n):
# Create a boolean array "prime[0..n]" and initialize
# all entries it as true. A value in prime[i] will
# finally be false if i is Not a prime, else true.
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
# If prime[p] is not changed, then it is a prime
if (prime[p] == True):
# Update all multiples of p
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
l=[]
for i in range(2,n+1):
if(prime[i]):
l.append(i)
return l
def bin(l,r,ll,val):
if(l>r):
return -1
else:
mid=(l+r)//2
if(val>=ll[mid][0] and val<=ll[mid][1]):
return mid
elif(val<ll[mid][0]):
return bin(l,mid-1,ll,val)
else:
return bin(mid+1,r,ll,val)
def deci(n):
s=""
while(n!=0):
if(n%2==0):
n=n//2
s="0"+s
else:
n=n//2
s="1"+s
return s
def diff(s1,s2):
if(len(s1)<len(s2)):
v=len(s1)
while(v!=len(s2)):
s1="0"+s1
v=v+1
else:
v=len(s2)
while(v!=len(s1)):
s2="0"+s2
v=v+1
c=0
for i in range(len(s1)):
if(s1[i:i+1]!=s2[i:i+1]):
c=c+1
return c
from sys import stdin, stdout
def fac(a,b):
v=a
while(a!=b):
v*=a-1
a=a-1
return v
def bino(l,r,n):
if(l>r):
return -1
else:
mid=(l+r)//2
val1=math.log((n/mid)+1,2)
val2=int(val1)
if(val1==val2):
return val1
elif(val1<1.0):
return bino(l,mid-1,n)
else:
return bino(mid+1,r,n)
def binary(l,r,ll,val,ans):
if(l>r):
return ans
else:
mid=(l+r)//2
if(val%ll[mid]==0):
ans=ll[mid]
return binary(l,mid-1,ll,val,ans)
else:
return binary(l,mid-1,ll,val,ans)
def odd(n,ans,s):
if(n%2!=0 or n in s):
return ans
else:
s.add(n)
return odd(n//2,ans+1,s)
if __name__ == '__main__':
dp=[]
for i in range(1000001):
dp.append(0)
for i in range(len(dp)):
if(i<10):
dp[i]=1
else:
val=i
count=0
while(True):
maxa=0
s=str(val)
for j in range(len(s)):
if(int(s[j:j+1])>maxa):
maxa=int(s[j:j+1])
val-=maxa
count+=1
if(val<=len(dp)):
dp[i]=count+dp[val]
break
else:
continue
# print(len(dp))
n=int(input())
if(n<=len(dp)):
print(dp[n])
else:
val=n
count=0
while(True):
maxa=0
s=str(val)
for j in range(len(s)):
if(int(s[j:j+1])>maxa):
maxa=int(s[j:j+1])
val-=maxa
count+=1
if(val<=len(dp)):
count=count+dp[val]
break
else:
continue
print(count)
```
|
instruction
| 0
| 1,934
| 2
| 3,868
|
No
|
output
| 1
| 1,934
| 2
| 3,869
|
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:
```
n=int(input())
lis=list(str(n))
sizz= len(lis)
count=0
while(len(lis)!=1):
m=0
for i in lis:
m=max(m,int(i))
temp=int(''.join(lis))
temp-=m
lis=list(str(temp))
count+=1
print(count+1)
```
|
instruction
| 0
| 1,935
| 2
| 3,870
|
No
|
output
| 1
| 1,935
| 2
| 3,871
|
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:
```
n = int(input())
d = {1:1,2:1,3:1,4:1,5:1,6:1,7:1,8:1,9:1}
for i in range(10,1001):
p = str(i).find("9")
if p==-1:
m = max([int(k) for k in str(i)])
d[i] = 1 + d[i - m]
else:
q = 1+int(int("0"+str(i)[(p+1):])/9)
d[i] = q+d[i-9*q]
c=0
while n!=0:
if n <= 1000:
c+=d[n]
n=0
else:
c+=153
n-=1000
print(c)
```
|
instruction
| 0
| 1,936
| 2
| 3,872
|
No
|
output
| 1
| 1,936
| 2
| 3,873
|
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:
```
def main():
n = int(input())
res = 20 * (n // 100)
i = n % 100
dec = False
while i % 10 != 0 and i % 9 != 0:
i -= 1
dec = True
if dec:
res += 1
if i % 10 == 0:
m = i // 10
res += 2 * m
elif i % 9 == 0:
m = i // 9
res += 2 * m - 1
print(res)
if __name__ == '__main__':
main()
```
|
instruction
| 0
| 1,937
| 2
| 3,874
|
No
|
output
| 1
| 1,937
| 2
| 3,875
|
End of preview. Expand
in Data Studio
- Downloads last month
- 1